input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
|
#include <bits/stdc++.h>
#define LL long long
using namespace std;
const int maxn=1e5+5;
struct node
{
LL a, b, c;
bool operator <(const node & A) const
{
return (a-b)<A.a-A.b;
}
}p[maxn];
LL lef[maxn];
priority_queue<LL, vector<LL>, greater<LL> >q;
int main()
{
int x, y, z;
cin>>x>>y>>z;
int i, j, n=x+y+z;
LL base=0;
for(i=1; i<=n; i++)
{
scanf("%lld%lld%lld", &p[i].a, &p[i].b, &p[i].c);
base+=p[i].c;
}
sort(p+1, p+1+n);
LL ans=0, sum=0;
for(i=1; i<=y; i++)
{
sum+=p[i].b-p[i].c;
q.push(p[i].b-p[i].c);
}
for(i=y+1; i<=n-x+1; i++)
{
lef[i]=sum;
sum+=p[i].b-p[i].c;
q.push(p[i].b-p[i].c);
sum-=q.top();
q.pop();
}
while(q.empty()==0)q.pop();
sum=0;
for(i=n; i>=n-x+1; i--)
{
sum+=p[i].a-p[i].c;
q.push(p[i].a-p[i].c);
}
for(; i>=y; i--)
{
ans=max(ans, base+lef[i+1]+sum);
// printf("%d %lld %lld %lld\n", i, base, lef[i+1], sum);
sum+=p[i].a-p[i].c;
q.push(p[i].a-p[i].c);
sum-=q.top();
q.pop();
}
printf("%lld\n", ans);
}
|
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
|
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.util.Random;
import java.io.OutputStreamWriter;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author ogiekako
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
MyScanner in = new MyScanner(inputStream);
MyPrintWriter out = new MyPrintWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
}
class TaskC {
public void solve(int testNumber, MyScanner in, MyPrintWriter out) {
int N = in.nextInt();
A = new long[N];
for (int i = 0; i < N; i++) A[i] = in.nextInt();
Graph G = new Graph(N);
for (int i = 0; i < N - 1; i++) {
int a = in.nextInt() - 1;
int b = in.nextInt() - 1;
G.add(a,b);
G.add(b,a);
}
int ans = -1;
for(int i=0;i<10;i++) {
int r = new Random().nextInt(N);
long res = dfs(G, r, -1);
int tmp = res == (lastDeg <= 1 ? A[r] : 0) ? 1 : 0;
if (ans == -1) ans = tmp;
else if (ans != tmp){
ans = -2;
break;
}
}
if (ans >= 0) {
out.println(ans==1 ? "YES" : "NO");
} else {
throw new RuntimeException();
}
}
long[] A;
int lastDeg;
private long dfs(Graph g, int root, int prev) {
long S = 0;
long max = 0;
int deg = 0;
for(Edge e : g.edges(root)) {
if (e.to() != prev) {
deg++;
long v = dfs(g, e.to(), root);
if (v < 0) return -1;
S += v;
max = Math.max(max, v);
}
}
if (A[root] < max) return -1;
if (deg > 0 && A[root] > S) return -1;
long res = deg == 0 ? A[root] : S - 2 * (S - A[root]);
if (res < 0) return -1;
lastDeg = deg;
return res;
}
}
class MyScanner {
private final InputStream in;
public MyScanner(InputStream in) {
this.in = in;
}
private static final int BUFSIZE = 65536;
int bufLen;
int bufPtr;
byte[] buf = new byte[BUFSIZE];
public int read() {
if (bufLen == -1)
throw new InputMismatchException();
if (bufPtr >= bufLen) {
bufPtr = 0;
try {
bufLen = in.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (bufLen <= 0)
return -1;
}
return buf[bufPtr++];
}
public int nextInt() {
int c = read();
if (c == -1) throw new NoSuchElementException();
while (c != '-' && (c < '0' || '9' < c)) {
c = read();
if (c == -1) throw new NoSuchElementException();
}
if (c == '-') return -nextInt();
int res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while ('0' <= c && c <= '9');
return res;
}
}
class MyPrintWriter {
PrintWriter out;
public MyPrintWriter(OutputStream outputStream) {
out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public void println(Object... os) {
if (os.length == 0) {
out.println();
return;
}
for (int i = 0; i < os.length - 1; i++) {
out.print(os[i]);
out.print(' ');
}
out.println(os[os.length - 1]);
}
public void close() {
out.close();
}
}
class Graph {
final int vertexCount;
private EdgeList[] edges;
public Graph(int vertexCount) {
this.vertexCount = vertexCount;
edges = new EdgeList[vertexCount];
for (int i = 0; i < vertexCount; i++) edges[i] = new EdgeList();
}
public void add(Edge edge) {
edges[edge.from()].add(edge);
Edge rev = edge.reversed();
if (rev != null) {
edges[rev.from()].add(rev);
}
}
public void add(int from, int to) {
add(new SimpleEdge(from, to));
}
public List<Edge> edges(int vertex) {
return edges[vertex];
}
public String toString() {
StringBuilder es = new StringBuilder();
for (int i = 0; i < vertexCount; i++) {
if (i > 0) es.append('\n');
es.append(edges(i));
}
return "Graph{" +
"edges=" + es +
'}';
}
private static class EdgeList extends ArrayList<Edge> {
EdgeList() {
super(0);
}
}
}
interface Edge {
int from();
int to();
Edge reversed();
}
class SimpleEdge implements Edge {
final int from;
final int to;
public SimpleEdge(int from, int to) {
this.from = from;
this.to = to;
}
public String toString() {
return from() + " -> " + to();
}
public int from() {
return from;
}
public int to() {
return to;
}
public Edge reversed() {
return null;
}
}
|
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int te; cin >> te;
while (te--){
int n, x; cin >> n >> x;
ll ans = 127 * (n - 1);
if (n & 1)
ans += x;
else
ans += 127 ^ x;
cout << ans << "\n";
}
return 0;
}
|
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
|
#include <string>
#include <iostream>
#include <sstream>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
const double EPS = 1e-9;
bool check(char a, char b, char c){
if(a == 's') return false;
return (a == b && b == c);
}
int main(){
string s;
char winner;
while(cin >> s){
winner = 'd';
for(int i = 0; i < 3; i++){
if( check(s[i], s[i+3], s[i+6]) ){
winner = s[i];
break;
}
}
for(int i = 0; i < 9; i+=3){
if( check(s[i], s[i+1], s[i+2]) ){
winner = s[i];
break;
}
}
if( check(s[2], s[4], s[6]) || check(s[0], s[4], s[8]) ){
winner = s[4];
}
cout << winner << endl;
}
return 0;
}
|
Artist Shinagawa was asked to exhibit n works. Therefore, I decided to exhibit the six sides of the cube colored with paint as a work. The work uses all six colors, Red, Yellow, Blue, Magenta, Green, and Cyan, and each side is filled with one color. Shinagawa changed the arrangement of colors even for cubic works with the same shape, and created n points as different works.
<image>
As a friend of mine, you, a friend of mine, allowed you to browse the work before exhibiting, and noticed that it was there. Even though they seemed to be colored differently, there were actually cubes with the same color combination. At this rate, it will not be possible to exhibit n works.
Please create a program that inputs the number of created works and the color information of each work and outputs how many more points you need to exhibit.
The color of each side of the cube is represented by the symbols from c1 to c6, and the arrangement is as follows. Also, each of c1 to c6 is one of Red, Yellow, Blue, Magenta, Green, and Cyan.
<image>
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
cube1
cube2
::
cuben
The first line gives the number of works n (1 ≤ n ≤ 30), and the following n lines give information on the i-th work. Information on each work is given in the following format.
c1 c2 c3 c4 c5 c6
The color arrangement ci of the work is given, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, output how many more works are needed to exhibit in one line.
Example
Input
3
Cyan Yellow Red Magenta Green Blue
Cyan Yellow Red Magenta Green Blue
Red Yellow Magenta Blue Green Cyan
4
Red Magenta Blue Green Yellow Cyan
Red Yellow Magenta Blue Green Cyan
Magenta Green Red Cyan Yellow Blue
Cyan Green Yellow Blue Magenta Red
0
Output
1
1
|
D = [
(1, 5, 2, 3, 0, 4), # 'U'
(3, 1, 0, 5, 4, 2), # 'R'
(4, 0, 2, 3, 5, 1), # 'D'
(2, 1, 5, 0, 4, 3), # 'L'
]
p_dice = (0, 0, 0, 1, 1, 2, 2, 3)*3
def rotate_dice(L0):
L = L0[:]
for k in p_dice:
yield L
L[:] = (L[e] for e in D[k])
while 1:
N = int(input())
if N == 0:
break
res = []
for i in range(N):
cube = input().split()
for dice in rotate_dice(cube):
if dice in res:
break
else:
res.append(cube)
print(N - len(res))
|
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
|
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
int a,b;
cin >> a >> b;
cout << (a+b)/2 << endl;
return 0;
}
|
In the Kingdom of IOI, the wind always blows from sea to land. There are $N + 1$ spots numbered from $0$ to $N$. The wind from Spot $0$ to Spot $N$ in order. Mr. JOI has a house at Spot $N$. The altitude of Spot $0$ is $A_0 = 0$, and the altitude of Spot $i$ ($1 \leq i \leq N$) is $A_i$.
The wind blows on the surface of the ground. The temperature of the wind changes according to the change of the altitude. The temperature of the wind at Spot $0$, which is closest to the sea, is $0$ degree. For each $i$ ($0 \leq i \leq N - 1$), the change of the temperature of the wind from Spot $i$ to Spot $i + 1$ depends only on the values of $A_i$ and $A_{i+1}$ in the following way:
* If $A_i < A_{i+1}$, the temperature of the wind decreases by $S$ degrees per altitude.
* If $A_i \geq A_{i+1}$, the temperature of the wind increases by $T$ degrees per altitude.
The tectonic movement is active in the land of the Kingdom of IOI. You have the data of tectonic movements for $Q$ days. In the $j$-th ($1 \leq j \leq Q$) day, the change of the altitude of Spot $k$ for $L_j \leq k \leq R_j$ ($1 \leq L_j \leq R_j \leq N$) is described by $X_j$. If $X_j$ is not negative, the altitude increases by $X_j$. If $X_j$ is negative, the altitude decreases by $|X_j|$.
Your task is to calculate the temperature of the wind at the house of Mr. JOI after each tectonic movement.
Task
Given the data of tectonic movements, write a program which calculates, for each $j$ ($1 \leq j \leq Q$), the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day.
Input
Read the following data from the standard input.
* The first line of input contains four space separated integers $N$, $Q$, $S$, $T$. This means there is a house of Mr. JOI at Spot $N$, there are $Q$ tectonic movements, the temperature of the wind decreases by $S$ degrees per altitude if the altitude increases, and the temperature of the wind increases by $T$ degrees per altitude if the altitude decreases.
* The $i$-th line ($1 \leq i \leq N +1$) of the following $N +1$ lines contains an integer $A_{i-1}$, which is the initial altitude at Spot ($i - 1$) before tectonic movements.
* The $j$-th line ($1 \leq j \leq Q$) of the following $Q$ lines contains three space separated integers $L_j$, $R_j$, $X_j$. This means, for the tectonic movement on the $j$-th day, the change of the altitude at the spots from $L_j$ to $R_j$ is described by $X_j$.
Output
Write $Q$ lines to the standard output. The $j$-th line ($1 \leq j \leq Q$) of output contains the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day.
Constraints
All input data satisfy the following conditions.
* $1 \leq N \leq 200 000．$
* $1 \leq Q \leq 200 000．$
* $1 \leq S \leq 1 000 000．$
* $1 \leq T \leq 1 000 000．$
* $A_0 = 0．$
* $-1 000 000 \leq A_i \leq 1 000 000 (1 \leq i \leq N)．$
* $1 \leq L_j \leq R_j \leq N (1 \leq j \leq Q)．$
* $ -1 000 000 \leq X_j \leq 1 000 000 (1 \leq j \leq Q)．$
Sample Input and Output
Sample Input 1
3 5 1 2
0
4
1
8
1 2 2
1 1 -2
2 3 5
1 2 -1
1 3 5
Sample Output 1
-5
-7
-13
-13
-18
Initially, the altitudes of the Spot 0, 1, 2, 3 are 0, 4, 1, 8, respectively. After the tectonic movement on the first day, the altitudes become 0, 6, 3, 8, respectively. At that moment, the temperatures of the wind are 0, -6, 0, -5,respectively.
Sample Input 2
2 2 5 5
0
6
-1
1 1 4
1 2 8
Sample Output 2
5
-35
Sample Input 3
7 8 8 13
0
4
-9
4
-2
3
10
-9
1 4 8
3 5 -2
3 3 9
1 7 4
3 5 -1
5 6 3
4 4 9
6 7 -10
Sample output 3
277
277
322
290
290
290
290
370
Creatie Commons License
The 16th Japanese Olympiad in Informatics (JOI 2016/2017) Final Round
Example
Input
3 5 1 2
0
4
1
8
1 2 2
1 1 -2
2 3 5
1 2 -1
1 3 5
Output
-5
-7
-13
-13
-18
|
#include<iostream>
#include<algorithm>
using namespace std;
int n,q,r,l;
long long s,t,a[200010],d[200010],x;
int main(){
cin>>n>>q>>s>>t;
for(int i=0;i<=n;i++)cin>>a[i];
long long cnt=0;
for(int i=0;i<n;i++){
d[i]=a[i+1]-a[i];
if(d[i]<0)cnt-=t*d[i];
if(d[i]>0)cnt-=s*d[i];
}
while(q--){
cin>>l>>r>>x;l--;
if(d[l]<0)cnt+=t*d[l];
if(d[l]>0)cnt+=s*d[l];
d[l]+=x;
if(d[l]<0)cnt-=t*d[l];
if(d[l]>0)cnt-=s*d[l];
if(r<n){
if(d[r]<0)cnt+=t*d[r];
if(d[r]>0)cnt+=s*d[r];
d[r]-=x;
if(d[r]<0)cnt-=t*d[r];
if(d[r]>0)cnt-=s*d[r];
}
cout<<cnt<<endl;
}
return 0;
}
|
A fraction whose numerator is 1 and whose denominator is a positive integer is called a unit fraction. A representation of a positive rational number p/q as the sum of finitely many unit fractions is called a partition of p/q into unit fractions. For example, 1/2 + 1/6 is a partition of 2/3 into unit fractions. The difference in the order of addition is disregarded. For example, we do not distinguish 1/6 + 1/2 from 1/2 + 1/6.
For given four positive integers p, q, a, and n, count the number of partitions of p/q into unit fractions satisfying the following two conditions.
* The partition is the sum of at most n many unit fractions.
* The product of the denominators of the unit fractions in the partition is less than or equal to a.
For example, if (p,q,a,n) = (2,3,120,3), you should report 4 since
2/3 = 1/3 + 1/3 = 1/2 + 1/6 = 1/4 + 1/4 + 1/6 = 1/3 + 1/6 + 1/6
enumerates all of the valid partitions.
Input
The input is a sequence of at most 1000 data sets followed by a terminator.
A data set is a line containing four positive integers p, q, a, and n satisfying p,q <= 800, a <= 12000 and n <= 7. The integers are separated by a space.
The terminator is composed of just one line which contains four zeros separated by a space. It is not a part of the input data but a mark for the end of the input.
Output
The output should be composed of lines each of which contains a single integer. No other characters should appear in the output.
The output integer corresponding to a data set p, q, a, n should be the number of all partitions of p/q into at most n many unit fractions such that the product of the denominators of the unit fractions is less than or equal to a.
Example
Input
2 3 120 3
2 3 300 3
2 3 299 3
2 3 12 3
2 3 12000 7
54 795 12000 7
2 3 300 1
2 1 200 5
2 4 54 2
0 0 0 0
Output
4
7
6
2
42
1
0
9
3
|
#include <bits/stdc++.h>
#define PB push_back
#define MP make_pair
#define REP(i,n) for (int i=0;i<(n);i++)
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define ALL(a) (a).begin(),(a).end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
double EPS=1e-10;
int p,q,a,n;
int rec(int x,int y,int cnt,int num){
if(cnt>n)return 0;
if(x*p==y*q)return 1;
if(x*p< y*q)return 0;
int res=0;
for(int i=num;i*x<=a;i++){
res+=rec(x*i,y*i+x,cnt+1,i);
}
return res;
}
int main(){
while(cin>>p>>q>>a>>n&&(p||q||a||n)){
cout<<rec(1,0,0,1)<<endl;
}
}
|
In the year 29XX, the government of a small country somewhere on the earth introduced a law restricting first names of the people only to traditional names in their culture, in order to preserve their cultural uniqueness. The linguists of the country specifies a set of rules once every year, and only names conforming to the rules are allowed in that year. In addition, the law also requires each person to use a name of a specific length calculated from one's birth date because otherwise too many people would use the same very popular names. Since the legislation of that law, the common task of the parents of new babies is to find the name that comes first in the alphabetical order among the legitimate names of the given length because names earlier in the alphabetical order have various benefits in their culture.
Legitimate names are the strings consisting of only lowercase letters that can be obtained by repeatedly applying the rule set to the initial string "S", a string consisting only of a single uppercase S.
Applying the rule set to a string is to choose one of the rules and apply it to the string. Each of the rules has the form A -> α, where A is an uppercase letter and α is a string of lowercase and/or uppercase letters. Applying such a rule to a string is to replace an occurrence of the letter A in the string to the string α. That is, when the string has the form "βAγ", where β and γ are arbitrary (possibly empty) strings of letters, applying the rule rewrites it into the string "βαγ". If there are two or more occurrences of A in the original string, an arbitrary one of them can be chosen for the replacement.
Below is an example set of rules.
S -> aAB (1)
A -> (2)
A -> Aa (3)
B -> AbbA (4)
Applying the rule (1) to "S", "aAB" is obtained. Applying (2) to it results in "aB", as A is replaced by an empty string. Then, the rule (4) can be used to make it "aAbbA". Applying (3) to the first occurrence of A makes it "aAabbA". Applying the rule (2) to the A at the end results in "aAabb". Finally, applying the rule (2) again to the remaining A results in "aabb". As no uppercase letter remains in this string, "aabb" is a legitimate name.
We denote such a rewriting process as follows.
(1) (2) (4) (3) (2) (2)
S --> aAB --> aB --> aAbbA --> aAabbA --> aAabb --> aabb
Linguists of the country may sometimes define a ridiculous rule set such as follows.
S -> sA (1)
A -> aS (2)
B -> b (3)
The only possible rewriting sequence with this rule set is:
(1) (2) (1) (2)
S --> sA --> saS --> sasA --> ...
which will never terminate. No legitimate names exist in this case. Also, the rule (3) can never be used, as its left hand side, B, does not appear anywhere else.
It may happen that no rules are supplied for some uppercase letters appearing in the rewriting steps. In its extreme case, even S might have no rules for it in the set, in which case there are no legitimate names, of course. Poor nameless babies, sigh!
Now your job is to write a program that finds the name earliest in the alphabetical order among the legitimate names of the given length conforming to the given set of rules.
Input
The input is a sequence of datasets, followed by a line containing two zeros separated by a space representing the end of the input. Each dataset starts with a line including two integers n and l separated by a space, where n (1 ≤ n ≤ 50) is the number of rules and l (0 ≤ l ≤ 20) is the required length of the name. After that line, n lines each representing a rule follow. Each of these lines starts with one of uppercase letters, A to Z, followed by the character "=" (instead of "->") and then followed by the right hand side of the rule which is a string of letters A to Z and a to z. The length of the string does not exceed 10 and may be zero. There appears no space in the lines representing the rules.
Output
The output consists of the lines showing the answer to each dataset in the same order as the input. Each line is a string of lowercase letters, a to z, which is the first legitimate name conforming to the rules and the length given in the corresponding input dataset. When the given set of rules has no conforming string of the given length, the corresponding line in the output should show a single hyphen, "-". No other characters should be included in the output.
Example
Input
4 3
A=a
A=
S=ASb
S=Ab
2 5
S=aSb
S=
1 5
S=S
1 0
S=S
1 0
A=
2 0
A=
S=AA
4 5
A=aB
A=b
B=SA
S=A
4 20
S=AAAAAAAAAA
A=aA
A=bA
A=
0 0
Output
abb
-
-
-
-
aabbb
aaaaaaaaaaaaaaaaaaaa
|
#include <string.h>
#include <ctype.h>
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
inline void cmin(string &a, const string& b) { if (a > b) a = b; }
inline void cmin(string &a, const string& b, const string& c) {
if (a.size() == 0) return ;
if (b.size() && b[0] == '|') return ;
if (c.size() && c[0] == '|') return ;
if (a.size() != b.size() + c.size()) {
a = b+c;
return ;
}
else {
int y = 0;
rep (i, b.size()) {
if (b[i] < a[i]) { y = -1; break; }
if (b[i] > a[i]) { y = 1; break; }
}
if (y == 0) rep (i, c.size()) {
if (c[i] < a[b.size()+i]) { y = -1; break; }
if (c[i] > a[b.size()+i]) { y = 1; break; }
}
if (y < 0) {
rep (i, b.size()) a[i] = b[i];
rep (i, c.size()) a[b.size()+i] = c[i];
}
}
}
int n, L;
char from[64];
string to[64];
int has[32][24];
string dp[32][24], sub[2][24];
int minL[32], maxL[32];
string solve() {
memset(has, 0, sizeof(has));
rep (i, 32) rep (j, 24) dp[i][j] = '-';
rep (i, 32) minL[i] = 1<<20;
rep (i, 32) maxL[i] = -(1<<20);
rep (LL, L+1) {
for (;;) {
bool update = false;
rep (k, n) {
int minE = 0, maxE = 0;
rep (i, to[k].size()) {
if (islower(to[k][i])) minE++, maxE++;
else {
const int t = to[k][i] - 'A';
minE += minL[t];
maxE += maxL[t];
}
}
if (LL < minE || maxE < LL) continue;
int cur = 0, nxt = 1;
rep (i, 24) sub[cur][i] = '|';
sub[cur][0] = "";
rep (i, to[k].size()) {
rep (j, 24) sub[nxt][j] = '|';
if (islower(to[k][i])) {
rep (x, LL) cmin(sub[nxt][x+1], sub[cur][x]+to[k][i]);
}
else {
const int t = to[k][i] - 'A';
rep (j, LL+1) if (has[t][j]) rep (x, LL-j+1) {
cmin(sub[nxt][x+j], sub[cur][x], dp[t][j]);
}
}
swap(cur, nxt);
}
const int f = from[k] - 'A';
if (sub[cur][LL] != "|") {
if (!has[f][LL] || dp[f][LL] > sub[cur][LL]) {
minL[f] = min(minL[f], LL);
maxL[f] = max(maxL[f], LL);
has[f][LL] = true;
update = true;
dp[f][LL] = sub[cur][LL];
}
}
}
if (!update) break;
}
}
return dp['S'-'A'][L];
}
int main() {
for (;;) {
cin >> n >> L;
if (n == 0) return 0;
string buf;
rep (i, n) {
cin >> buf;
from[i] = buf[0];
to[i] = buf.substr(2);
}
cout << solve() << endl;
}
}
|
Reordering the Documents
Susan is good at arranging her dining table for convenience, but not her office desk.
Susan has just finished the paperwork on a set of documents, which are still piled on her desk. They have serial numbers and were stacked in order when her boss brought them in. The ordering, however, is not perfect now, as she has been too lazy to put the documents slid out of the pile back to their proper positions. Hearing that she has finished, the boss wants her to return the documents immediately in the document box he is sending her. The documents should be stowed in the box, of course, in the order of their serial numbers.
The desk has room just enough for two more document piles where Susan plans to make two temporary piles. All the documents in the current pile are to be moved one by one from the top to either of the two temporary piles. As making these piles too tall in haste would make them tumble, not too many documents should be placed on them. After moving all the documents to the temporary piles and receiving the document box, documents in the two piles will be moved from their tops, one by one, into the box. Documents should be in reverse order of their serial numbers in the two piles to allow moving them to the box in order.
For example, assume that the pile has six documents #1, #3, #4, #2, #6, and #5, in this order from the top, and that the temporary piles can have no more than three documents. Then, she can form two temporary piles, one with documents #6, #4, and #3, from the top, and the other with #5, #2, and #1 (Figure E.1). Both of the temporary piles are reversely ordered. Then, comparing the serial numbers of documents on top of the two temporary piles, one with the larger number (#6, in this case) is to be removed and stowed into the document box first. Repeating this, all the documents will be perfectly ordered in the document box.
<image>
Figure E.1. Making two temporary piles
Susan is wondering whether the plan is actually feasible with the documents in the current pile and, if so, how many different ways of stacking them to two temporary piles would do. You are asked to help Susan by writing a program to compute the number of different ways, which should be zero if the plan is not feasible.
As each of the documents in the pile can be moved to either of the two temporary piles, for $n$ documents, there are $2^n$ different choice combinations in total, but some of them may disturb the reverse order of the temporary piles and are thus inappropriate.
The example described above corresponds to the first case of the sample input. In this case, the last two documents, #5 and #6, can be swapped their destinations. Also, exchanging the roles of two temporary piles totally will be OK. As any other move sequences would make one of the piles higher than three and/or make them out of order, the total number of different ways of stacking documents to temporary piles in this example is $2 \times 2 = 4$.
Input
The input consists of a single test case of the following format.
$n$ $m$
$s_1$ ... $s_n$
Here, $n$ is the number of documents in the pile ($1 \leq n \leq 5000$), and $m$ is the number of documents that can be stacked in one temporary pile without committing risks of making it tumble down ($n/2 \leq m \leq n$). Numbers $s_1$ through $s_n$ are the serial numbers of the documents in the document pile, from its top to its bottom. It is guaranteed that all the numbers $1$ through $n$ appear exactly once.
Output
Output a single integer in a line which is the number of ways to form two temporary piles suited for the objective. When no choice will do, the number of ways is $0$, of course.
If the number of possible ways is greater than or equal to $10^9 + 7$, output the number of ways modulo $10^9 + 7$.
Sample Input 1
6 3
1 3 4 2 6 5
Sample Output 1
4
Sample Input 2
6 6
1 3 4 2 6 5
Sample Output 2
8
Sample Input 3
4 4
4 3 1 2
Sample Output 3
0
Example
Input
6 3
1 3 4 2 6 5
Output
4
|
#include <bits/stdc++.h>
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<db,db> pdb;
typedef tuple<int,int,int> tii;
typedef tuple<ll,ll,ll> tll;
typedef vector<vector<ll>> mat;
const ll mod=1e9+7;
const int N=5005;
int n,m,a[N],mn[N],mx[N];
ll dp[N][N],ans;
int main(){
ios::sync_with_stdio(false); cin.tie(0);
cin>>n>>m;
if(!m){
cout<<0;
return 0;
}
for(int i=1;i<=n;i++){
cin>>a[i];
mx[i]=max(mx[i-1],a[i]);
}
mn[n]=1e9;
for(int i=n-1;i;i--) mn[i]=min(mn[i+1],a[i+1]);
dp[1][1]=2;
for(int i=2;i<=n;i++){
if(a[i]!=mx[i]){
if(a[i]>=mn[i]) break;
for(int j=1;j<=m;j++) if(max(j,i-j)<=m) dp[i][j]=dp[i-1][j];
} else{
for(int j=1;j<=m;j++) if(max(j,i-j)<=m) dp[i][j]=dp[i-1][j-1];
if(mx[i-1]<=mn[i]) for(int j=1;j<=m;j++) if(max(j,i-j)<=m) (dp[i][j]+=dp[i-1][i-j])%=mod;
}
}
for(int i=1;i<=m;i++) (ans+=dp[n][i])%=mod;
cout<<ans<<"\n";
return 0;
}
|
Expression Mining
Consider an arithmetic expression built by combining single-digit positive integers with addition symbols `+`, multiplication symbols `*`, and parentheses `(` `)`, defined by the following grammar rules with the start symbol `E`.
E ::= T | E '+' T
T ::= F | T '*' F
F ::= '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '(' E ')'
When such an arithmetic expression is viewed as a string, its substring, that is, a contiguous sequence of characters within the string, may again form an arithmetic expression. Given an integer n and a string s representing an arithmetic expression, let us count the number of its substrings that can be read as arithmetic expressions with values computed equal to n.
Input
The input consists of multiple datasets, each in the following format.
> n
> s
>
A dataset consists of two lines. In the first line, the target value n is given. n is an integer satisfying 1 ≤ n ≤ 109. The string s given in the second line is an arithmetic expression conforming to the grammar defined above. The length of s does not exceed 2×106. The nesting depth of the parentheses in the string is at most 1000.
The end of the input is indicated by a line containing a single zero. The sum of the lengths of s in all the datasets does not exceed 5×106.
Output
For each dataset, output in one line the number of substrings of s that conform to the above grammar and have the value n. The same sequence of characters appearing at different positions should be counted separately.
Sample Input
3
(1+2)*3+3
2
1*1*1+1*1*1
587
1*(2*3*4)+5+((6+7*8))*(9)
0
Output for the Sample Input
4
9
2
Example
Input
3
(1+2)*3+3
2
1*1*1+1*1*1
587
1*(2*3*4)+5+((6+7*8))*(9)
0
Output
4
9
2
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
#define ALL(v) begin(v),end(v)
typedef long long LL;
const LL INF = 1010101010;
struct solver{
enum nodetype{
CON, PAR, ADD, MUL
};
struct node{
nodetype tp;
LL val;
vector<int> child;
vector<LL> psum;
};
vector<node> nodes;
LL n;
const char *p;
LL ans;
LL solve(int n_, const string &s){
n = n_;
ans = 0;
for(int i = 0; i < 10; ++i){
int k = newnode(CON);
nodes[k].val = i;
}
p = s.c_str();
int root = expr();
dfs(root);
return ans;
}
int newnode(nodetype tp){
nodes.emplace_back();
nodes.back().tp = tp;
return nodes.size() - 1;
}
int factor(){
if(*p == '('){
++p;
int e = expr();
++p;
int ret = newnode(PAR);
nodes[ret].val = nodes[e].val;
nodes[ret].child.push_back(e);
return ret;
}
int k = *p - '0';
++p;
if(k < 0 || k > 9){ throw 0; }
return k;
}
int term(){
int f = factor();
if(*p != '*'){ return f; }
int ret = newnode(MUL);
LL val = nodes[f].val;
nodes[ret].child.push_back(f);
nodes[ret].psum.push_back(val);
while(*p == '*'){
++p;
f = factor();
val = min(val * nodes[f].val, INF);
nodes[ret].child.push_back(f);
nodes[ret].psum.push_back(val);
}
nodes[ret].val = val;
return ret;
}
int expr(){
int t = term();
if(*p != '+'){ return t; }
int ret = newnode(ADD);
LL val = nodes[t].val;
nodes[ret].child.push_back(t);
nodes[ret].psum.push_back(val);
while(*p == '+'){
++p;
t = term();
val += nodes[t].val;
nodes[ret].child.push_back(t);
nodes[ret].psum.push_back(val);
}
nodes[ret].val = min(val, INF);
return ret;
}
void procadd(node &nd, int lt, LL accl){
if(accl >= n){ return; }
int sz = nd.psum.size();
int rt = lower_bound(ALL(nd.psum), n - accl + nd.psum[lt]) - nd.psum.begin();
if(rt <= lt || rt >= sz){ return; }
node &rch = nodes[nd.child[rt]];
if(rch.tp == MUL){
LL tgt = n - accl - (nd.psum[rt - 1] - nd.psum[lt]);
int k1 = lower_bound(ALL(rch.psum), tgt) - rch.psum.begin();
int k2 = upper_bound(ALL(rch.psum), tgt) - rch.psum.begin();
ans += k2 - k1;
}
else if(nd.psum[rt] == n - accl + nd.psum[lt]){
++ans;
}
}
void dfs(int u){
node &nd = nodes[u];
if(nd.val < n){ return; }
for(int c : nd.child){ dfs(c); }
int sz = nd.child.size();
if(nd.tp == ADD){
for(int lt = 0; lt + 1 < sz; ++lt){
node &lch = nodes[nd.child[lt]];
if(lch.tp == MUL){
LL accl = 1;
for(int i = lch.child.size(); i--; ){
accl *= nodes[lch.child[i]].val;
if(accl >= n){ break; }
procadd(nd, lt, accl);
}
}
else{
procadd(nd, lt, nodes[nd.child[lt]].val);
}
}
}
else if(nd.tp == MUL){
LL acc = 1;
int rt = 0;
int con1 = 0;
for(int lt = 0; lt < sz; ++lt){
if(rt <= lt){
rt = lt;
con1 = 0;
acc = 1;
}
while(rt < sz){
if(acc > n){ break; }
LL v = nodes[nd.child[rt]].val;
if(v == 1){
++con1;
}
else if(acc == n){ break; }
else{
con1 = 0;
acc *= v;
}
++rt;
}
if(acc == n && rt - lt > 1){
LL t = min(con1, rt - lt - 2);
ans += t + 1;
}
acc /= nodes[nd.child[lt]].val;
}
}
else{
if(nd.val == n){ ++ans; }
}
}
};
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
string s;
while(cin >> n >> s){
LL ans = solver().solve(n, s);
cout << ans << '\n';
}
}
|
T.I. Financial Group, a world-famous group of finance companies, has decided to hold an evil gambling game in which insolvent debtors compete for special treatment of exemption from their debts.
In this game, each debtor starts from one cell on the stage called the Deadly Ring. The Deadly Ring consists of N cells and each cell is colored black or red. Each cell is connected to exactly two other adjacent cells and all the cells form a ring. At the start of the game, each debtor chooses which cell to start. Then he rolls a die and moves on the ring in clockwise order by cells as many as the number of spots shown on the upside of the die. This step is called a round, and each debtor repeats a round T times. A debtor will be exempted from his debt if he is standing on a red cell after he finishes all the rounds. On the other hand, if he finishes the game at a black cell, he will be sent somewhere else and forced to devote his entire life to hard labor.
You have happened to take part in this game. As you are allowed to choose the starting cell, you want to start from a cell that maximizes the probability of finishing the game at a red cell. Fortunately you can bring a laptop PC to the game stage, so you have decided to write a program that calculates the maximum winning probability.
Input
The input consists of multiple datasets.
Each dataset consists of two lines. The first line contains two integers N (1 ≤ N ≤ 2000) and T (1 ≤ T ≤ 2000) in this order, delimited with a single space. The second line contains a string of N characters that consists of characters ‘R’ and ‘B’, which indicate red and black respectively. This string represents the colors of the cells in clockwise order.
The input is terminated by a line with two zeros. This is not part of any datasets and should not be processed.
Output
For each dataset, print the maximum probability of finishing the game at a red cell in one line. Your program may output an arbitrary number of digits after the decimal point, provided that the absolute error does not exceed 10-8.
Example
Input
6 1
RBRBRB
10 1
RBBBRBBBBB
10 2
RBBBRBBBBB
10 10
RBBBBBBBBB
0 0
Output
0.50000000
0.33333333
0.22222222
0.10025221
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
string mp;
int n,T;
double mem[2001][2001];
bool used[2001][2001];
double dfs(int t,int pos){
if(t==T)return mem[t][pos]=(mp[pos]=='R');
if(used[t][pos])return mem[t][pos];
used[t][pos]=1;
double res=0;
for(int i=1;i<=6;i++)res+=dfs(t+1,(pos+i)%n);
return mem[t][pos]=res/6;
}
int main(){
while(1){
cin>>n>>T;
if(!n&&!T)break;
cin>>mp;
memset(used,0,sizeof(used));
for(int i=0;i<2001;i++)
for(int j=0;j<2001;j++) mem[i][j]=0;
double ans=0;
for(int i=0;i<n;i++) ans=max(ans,dfs(0,i));
printf("%.10f\n",ans);
}
return 0;
}
|
Training is indispensable for achieving good results at ICPC. Rabbit wants to win at ICPC, so he decided to practice today as well.
Today's training is to increase creativity by drawing pictures. Let's draw a pattern well using a square stamp.
I want to use stamps of various sizes to complete the picture of the red, green, and blue streets specified on the 4 x 4 squared paper. The stamp is rectangular and is used to fit the squares. The height and width of the stamp cannot be swapped.
The paper is initially uncolored. When you stamp on paper, the stamped part changes to the color of the stamp, and the color hidden underneath becomes completely invisible. Since the color of the stamp is determined by the ink to be applied, it is possible to choose the color of any stamp. The stamp can be stamped with a part protruding from the paper, and the protruding part is ignored.
It is possible to use one stamp multiple times. You may use the same stamp for different colors. Stamping is a rather nerve-wracking task, so I want to reduce the number of stamps as much as possible.
Input
N
H1 W1
...
HN WN
C1,1C1,2C1,3C1,4
C2,1C2,2C2,3C2,4
C3,1C3,2C3,3C3,4
C4,1C4,2C4,3C4,4
N is the number of stamps, and Hi and Wi (1 ≤ i ≤ N) are integers representing the vertical and horizontal lengths of the i-th stamp, respectively. Ci, j (1 ≤ i ≤ 4, 1 ≤ j ≤ 4) is a character that represents the color of the picture specified for the cells in the i-th row from the top and the j-th column from the left. Red is represented by `R`, green is represented by` G`, and blue is represented by `B`.
Satisfy 1 ≤ N ≤ 16, 1 ≤ Hi ≤ 4, 1 ≤ Wi ≤ 4. The same set as (Hi, Wi) does not appear multiple times.
Output
Print the minimum number of stamps that must be stamped to complete the picture on a single line.
Examples
Input
2
4 4
1 1
RRRR
RRGR
RBRR
RRRR
Output
3
Input
1
2 3
RRGG
BRGG
BRRR
BRRR
Output
5
|
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cstring>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <bitset>
#include <numeric>
#include <utility>
#include <iomanip>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef pair<int,int> pint;
#define DE 1
#define FI first
#define SE second
#define PB push_back
#define MP make_pair
#define ALL(s) (s).begin(),(s).end()
#define REP(i,n) for (int i = 0; i < (int)(n); ++i)
#define EACH(i,s) for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)
#define FOR_SUBSET(b, a) for(int b = a; b != 0; b = (b-1)&a)
#define COUT(x) cout<<#x<<" = "<<(x)<<" (L"<<__LINE__<<")"<<endl
template<class T1, class T2> ostream& operator<<(ostream &s, pair<T1,T2> P){return s<<'<'<<P.first<<", "<<P.second<<'>';}
template<class T> ostream& operator<<(ostream &s, vector<T> P) {s<<"{ ";for(int i=0;i<P.size();++i){if(i>0)s<<", ";s<<P[i];}return s<<" }"<<endl;}
template<class T1, class T2> ostream& operator<<(ostream &s, map<T1,T2> P) {s<<"{ ";for(__typeof__(P.begin()) it=P.begin();it!=P.end();++it){if(it!=P.begin())s<<", ";s<<'<'<<it->first<<"->"<<it->second<<'>';}return s<<" }"<<endl;}
const int MAX = 20;
const int INF = 1<<29;
int dp[1<<17];
int n;
int a[MAX], b[MAX];
char field[4][4];
char color[3] = {'R', 'G', 'B'};
int ind(int i, int j) {
return i*4+j;
}
void debug(int bit) {
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
cout << ((bit & (1<<ind(i,j))) != 0);
}
cout << endl;
}
cout << " : " << dp[bit] << endl << endl;
}
int main() {
//freopen( "/Users/macuser/Documents/Programming/Contest/input.in", "r", stdin );
while (cin >> n) {
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i];
}
for (int i = 0; i < 4; ++i)
for (int j = 0; j < 4; ++j)
cin >> field[i][j];
for (int bit = 0; bit < (1<<16); ++bit) dp[bit] = INF;
dp[0] = 0;
for (int bit = 0; bit < (1<<16); ++bit) {
//debug(bit);
for (int id = 0; id < n; ++id) {
int from1 = 1 - a[id], from2 = 1-b[id];
for (int i = from1; i < 4; ++i) {
for (int j = from2; j < 4; ++j) {
for (int col = 0; col < 3; ++col) {
char c = color[col];
bool ok = true;
int addbit = 0;
for (int k = max(0, i); k < min(4, i+a[id]); ++k) {
for (int l = max(0, j); l < min(4, j+b[id]); ++l) {
if ((bit & (1<<ind(k,l))) && field[k][l] != c) ok = false;
if (!(bit & (1<<ind(k,l))) && field[k][l] == c) addbit += 1<<ind(k,l);
}
}
if (ok) {
FOR_SUBSET(subbit, addbit) {
int nbit = bit | subbit;
dp[nbit] = min(dp[nbit], dp[bit]+1);
}
}
}
}
}
}
}
cout << dp[(1<<16)-1] << endl;
}
return 0;
}
|
In the International City of Pipe Construction, it is planned to repair the water pipe at a certain point in the water pipe network. The network consists of water pipe segments, stop valves and source point. A water pipe is represented by a segment on a 2D-plane and intersected pair of water pipe segments are connected at the intersection point. A stop valve, which prevents from water flowing into the repairing point while repairing, is represented by a point on some water pipe segment. In the network, just one source point exists and water is supplied to the network from this point.
Of course, while repairing, we have to stop water supply in some areas, but, in order to reduce the risk of riots, the length of water pipes stopping water supply must be minimized. What you have to do is to write a program to minimize the length of water pipes needed to stop water supply when the coordinates of end points of water pipe segments, stop valves, source point and repairing point are given.
Input
A data set has the following format:
> N M
> xs1 ys1 xd1 yd1
> ...
> xsN ysN xdN ydN
> xv1 yv1
> ...
> xvM yvM
> xb yb
> xc yc
>
The first line of the input contains two integers, N (1 ≤ N ≤ 300) and M (0 ≤ M ≤ 1,000) that indicate the number of water pipe segments and stop valves. The following N lines describe the end points of water pipe segments. The i-th line contains four integers, xsi, ysi, xdi and ydi that indicate the pair of coordinates of end points of i-th water pipe segment. The following M lines describe the points of stop valves. The i-th line contains two integers, xvi and yvi that indicate the coordinate of end points of i-th stop valve. The following line contains two integers, xb and yb that indicate the coordinate of the source point. The last line contains two integers, xc and yc that indicate the coordinate of the repairing point.
You may assume that any absolute values of coordinate integers are less than 1,000 (inclusive.) You may also assume each of the stop valves, the source point and the repairing point is always on one of water pipe segments and that that each pair among the stop valves, the source point and the repairing point are different. And, there is not more than one intersection between each pair of water pipe segments. Finally, the water pipe network is connected, that is, all the water pipes are received water supply initially.
Output
Print the minimal length of water pipes needed to stop water supply in a line. The absolute or relative error should be less than or 10-6. When you cannot stop water supply to the repairing point even though you close all stop valves, print "`-1`" in a line.
Examples
Input
1 2
0 0 10 0
1 0
9 0
0 0
5 0
Output
9.0
Input
5 3
0 4 2 4
0 2 2 2
0 0 2 0
0 0 0 4
2 0 2 4
0 2
1 0
2 2
1 4
2 1
Output
3.0
Input
2 1
0 0 0 4
0 2 2 2
1 2
0 1
0 3
Output
-1
|
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define EPS (1e-12)
#define equals(a,b) (fabs((a)-(b)) < EPS)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
using namespace std;
class Point{
public:
double x,y;
Point(double x = 0,double y = 0): x(x),y(y){}
Point operator + (Point p){return Point(x+p.x,y+p.y);}
Point operator - (Point p){return Point(x-p.x,y-p.y);}
Point operator * (double a){return Point(a*x,a*y);}
Point operator / (double a){return Point(x/a,y/a);}
Point operator * (Point a){ return Point(x * a.x - y * a.y, x * a.y + y * a.x); }
bool operator < (const Point& p) const{ return !equals(x,p.x)?x<p.x:(!equals(y,p.y)&&y<p.y); }
bool operator == (const Point& p)const{ return equals(x,p.x) && equals(y,p.y); }
};
struct Segment{
Point p1,p2;
Segment(Point p1 = Point(),Point p2 = Point()):p1(p1),p2(p2){}
bool operator < (const Segment& s) const { return ( p2 == s.p2 ) ? p1 < s.p1 : p2 < s.p2; }
bool operator == (const Segment& s) const { return ( s.p1 == p1 && s.p2 == p2 ) || ( s.p1 == p2 && s.p2 == p1 ); }
};
typedef Point Vector;
typedef Segment Line;
double dot(Point a,Point b){ return a.x*b.x + a.y*b.y; }
double cross(Point a,Point b){ return a.x*b.y - a.y*b.x; }
double norm(Point a){ return a.x*a.x+a.y*a.y; }
double abs(Point a){ return sqrt(norm(a)); }
int ccw(Point p0,Point p1,Point p2){
Point a = p1-p0;
Point b = p2-p0;
if(cross(a,b) > EPS)return COUNTER_CLOCKWISE;
if(cross(a,b) < -EPS)return CLOCKWISE;
if(dot(a,b) < -EPS)return ONLINE_BACK;
if(norm(a) < norm(b))return ONLINE_FRONT;
return ON_SEGMENT;
}
bool intersectSS(Line s, Line t) {
return ccw(s.p1,s.p2,t.p1)*ccw(s.p1,s.p2,t.p2) <= 0 &&
ccw(t.p1,t.p2,s.p1)*ccw(t.p1,t.p2,s.p2) <= 0;
}
bool intersectSP(Line s, Point p) { return abs(s.p1-p)+abs(s.p2-p)-abs(s.p2-s.p1) < EPS; }
Point projection(Line l,Point p) {
double t = dot(p-l.p1, l.p1-l.p2) / norm(l.p1-l.p2);
return l.p1 + (l.p1-l.p2)*t;
}
double distanceSP(Line s, Point p) {
Point r = projection(s, p);
if (intersectSP(s, r)) return abs(r - p);
return min(abs(s.p1 - p), abs(s.p2 - p));
}
double distanceSS(Line s, Line t) {
if (intersectSS(s, t)) return 0;
return min(min(distanceSP(s, t.p1), distanceSP(s, t.p2)),
min(distanceSP(t, s.p1), distanceSP(t, s.p2)));
}
Point crosspoint(Line l,Line m){
double A = cross(l.p2-l.p1,m.p2-m.p1);
double B = cross(l.p2-l.p1,l.p2-m.p1);
if(abs(A) < EPS && abs(B) < EPS){
vector<Point> vec;
vec.push_back(l.p1),vec.push_back(l.p2),vec.push_back(m.p1),vec.push_back(m.p2);
sort(vec.begin(),vec.end());
return vec[1];
}
if(abs(A) < EPS)assert(false);
return m.p1 + (m.p2-m.p1)*(B/A);
}
struct Edge {
int from,to;
double cost;
Edge(int from=0,int to=0,double cost=0):from(from),to(to),cost(cost){}
bool operator < (const Edge& a)const { return !equals(cost,a.cost) && cost < a.cost; }
};
vector<vector<Edge> > segmentArrangement(vector<Segment> vs,vector<Point> &ps) {
rep(i,vs.size()) REP(j,i+1,vs.size()) if(intersectSS(vs[i],vs[j])) ps.push_back(Point(crosspoint(vs[i],vs[j])));
sort(ps.begin(),ps.end());
ps.erase(unique(ps.begin(),ps.end()),ps.end());
vector<vector<Edge> > ret(ps.size());
for(int i=0;i<vs.size();i++){
vector<pair<double,int> > list;
rep(j,ps.size()) if(intersectSP(vs[i],ps[j]))list.push_back(pair<double,int>(norm(vs[i].p1-ps[j]),j));
sort(list.begin(),list.end());
for(int j=0;j+1<list.size();++j) {
int from = list[j].second, to = list[j+1].second;
double cost = abs(ps[from]-ps[to]);
ret[from].push_back(Edge(from,to,cost));
ret[to].push_back(Edge(to,from,cost));
}
}
return ret;
}
int N,M;
vector<Segment> segs;
vector<Point> stop;
Point source,repairing;
void compute(){
double total = 0;
vector<Point> ps = stop;
ps.push_back(source);
ps.push_back(repairing);
rep(i,(int)segs.size()) ps.push_back(segs[i].p1), ps.push_back(segs[i].p2),
total += abs(segs[i].p1-segs[i].p2);
vector<vector<Edge> > G = segmentArrangement(segs,ps);
int sp = -1, rp = -1;
rep(i,ps.size()) {
if( source == ps[i] ) sp = i;
if( repairing == ps[i] ) rp = i;
}
sort(stop.begin(),stop.end());
vector<bool> stopper(ps.size(),false);
rep(i,stop.size()) {
int position = lower_bound(ps.begin(),ps.end(),stop[i]) - ps.begin();
assert( position < ps.size() );
stopper[position] = true;
}
deque<int> deq;
vector<bool> out(ps.size(),false);
deq.push_back(rp);
out[rp] = true;
while( !deq.empty() ){
int cur = deq.front(); deq.pop_front();
rep(i,(int)G[cur].size()) {
int to = G[cur][i].to;
if( out[to] ) continue;
out[to] = true;
if( stopper[to] ) continue;
deq.push_back(to);
}
}
if( out[sp] ) { puts("-1"); return; }
double reach = 0;
typedef pair<int,int> ii;
set<ii> added,used;
assert( deq.empty() );
deq.push_back(sp);
while( !deq.empty() ){
int cur = deq.front(); deq.pop_front();
rep(i,(int)G[cur].size()){
int to = G[cur][i].to;
ii data = ii(min(cur,to),max(cur,to));
if( !added.count(data) ) {
added.insert(data);
reach += abs(ps[cur]-ps[to]);
}
if( out[to] ) continue;
if( used.count( ii(cur,to) ) ) continue;
used.insert(ii(cur,to));
deq.push_back(to);
}
}
printf("%.10f\n",total-reach);
}
int main(){
scanf("%d %d",&N,&M);
segs.clear(), stop.clear();
segs.resize(N), stop.resize(M);
rep(i,N) cin >> segs[i].p1.x >> segs[i].p1.y >> segs[i].p2.x >> segs[i].p2.y;
rep(i,M) cin >> stop[i].x >> stop[i].y;
cin >> source.x >> source.y;
cin >> repairing.x >> repairing.y;
compute();
return 0;
}
|
The city of Kyoto is a famous tourist destination for old temples and shrines.
Ikta came to Kyoto sightseeing with a few friends, but as a result of all acting freely, they all got lost.
So Ikta decided to think about where to meet in order to meet everyone as soon as possible.
Kyoto's roads run innumerably at intervals of 10 from east to west and north to south, and can be regarded as an infinitely wide square grid.
Roads are considered straight and have no width. In addition, the position moved by a distance x to the east and a distance y to the north with respect to the center of the city is represented by the coordinates (x, y).
At the center of the city (0,0), the east-west road and the north-south road intersect.
The figure below illustrates the roads of Kyoto and the coordinates of some points.
<image>
Since the coordinates (Xi, Yi) of N tourists are given as integers, answer the minimum time required for N people to move on the road and gather at one point.
Tourists can move continuously on the road at a speed of 1 distance per hour.
The coordinates of the N tourists given are different, and all coordinates are guaranteed to be on the road.
It is also possible for multiple tourists to exist at one point at the same time, or for tourists to move so that they pass each other.
Input
The input is given in the following format.
> N
> X1 Y1
> ...
> XN YN
>
N in the first line is the number of tourists. The i-th line (1 ≤ i ≤ N) of the next N lines represents the location of the i-th tourist (Xi, Yi). Xi and Yi are given as integers, respectively.
Constraints
Each variable being input satisfies the following constraints.
* 2 ≤ N ≤ 10000
* −108 ≤ Xi, Yi ≤ 108
* When i ≠ j (Xi, Yi) ≠ (Xj, Yj)
* At least one of Xi and Yi is a multiple of 10.
Output
Print the solution to the problem on one line. Allows absolute error up to 10-3.
Examples
Input
3
5 10
-10 0
3 -10
Output
14
Input
2
0 0
0 1
Output
0.5
Input
4
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
200000000
|
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"
using namespace std;
constexpr long long int MOD = 1000000007;
//constexpr int MOD = 1000000007;
//constexpr int MOD = 998244353;
//constexpr long long int MOD = 998244353;
constexpr double EPS = 1e-9;
//int N, M, K, H, W, L, R;
long long int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
vector<int>x(N);
vector<int>y(N);
int xl = MOD, xr = -MOD, yl = MOD, yr = -MOD;
for (int i = 0; i < N; i++) {
cin >> x[i] >> y[i];
x[i] <<= 1, y[i] <<= 1;
x[i] += 400000000;
y[i] += 100000000;
int X, Y;
tie(X, Y) = make_pair(x[i] + y[i], x[i] - y[i]);
xl = min(xl, X);
xr = max(xr, X);
yl = min(yl, Y);
yr = max(yr, Y);
}
int xmid = (xl + xr) / 2;
int ymid = (yl + yr) / 2;
int ans = MOD;
int len = 100;
for (int i = xmid - len; i <= xmid + len; i++) {
for (int j = ymid - len; j <= ymid + len; j++) {
if (abs(i - j) % 2)continue;
int w = (i + j) / 2;
int h = i - w;
if (w % 20 && h % 20)continue;
int box = 0;
for (int k = 0; k < N; k++) {
if ((w+1000000000) / 20 == (x[k]+1000000000) / 20) {
if (h == y[k])box = max(box, abs(w - x[k]));
else box = max(box, abs(h - y[k]) + min(40 - (w % 20 + x[k] % 20), (w % 20 + x[k] % 20)));
}
else if ((h+1000000000) / 20 == (y[k]+1000000000) / 20) {
if (w == x[k])box = max(box, abs(h - y[k]));
else box = max(box, abs(w - x[k]) + min(40 - (h % 20 + y[k] % 20), (h % 20 + y[k] % 20)));
}
else {
box = max(box, abs(h - y[k]) + abs(w - x[k]));
}
}
//cout << w << " " << h << " " << box << endl;
ans = min(ans, box);
}
}
cout << ans / 2;
if (ans & 1)cout << "." << 5;
cout << endl;
}
|
Problem statement
Here are $ N $ sheets of paper. You want to scan all paper by using $ 3 $ scanners in parallel. Each piece of paper has a fixed scanning time, and the time it takes to scan the $ i $ th paper is $ T_i $. You can scan the paper in any order, but you cannot scan multiple papers at the same time with a $ 1 $ scanner.
Minimize the time it takes to finish scanning all paper and run out of scanners.
Constraint
$ 1 \ leq N \ leq 50 $
$ 1 \ leq T_i \ leq 50 $
All inputs are integers
sample
Sample input 1
Four
1
1
1
1
Sample output 1
2
<image>
Sample input 2
9
15
20
27
Four
Ten
7
34
30
36
Sample output 2
61
<image>
Sample input 3
6
20
18
46
16
9
48
Sample output 3
55
<image>
input
$ N $
$ T_1 $
$ T_2 $
$ T_3 $
$ \ vdots $
$ T_N $
output
Print the answer on the $ 1 $ line.
Example
Input
4
1
1
1
1
Output
2
|
#define _USE_MATH_DEFINES
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
using namespace std;
typedef pair<long long int, long long int> P;
long long int INF = 1e18;
long long int MOD = 1e9 + 7;
bool DP[1000][1000] = {};
int main(){
int N;
cin >> N;
DP[0][0] = true;
int S = 0;
for(int loop = 0; loop < N; loop++){
int T;
cin >> T;
for(int i = 999 - T; i >= 0; i--){
for(int j = 999 - T; j >= 0; j--){
if(DP[i][j]){
DP[i + T][j] = true;
DP[i][j + T] = true;
}
}
}
S += T;
}
int ans = 1000;
for(int i = 0; i < 1000; i++){
for(int j = 0; j < 1000; j++){
if(DP[i][j]){
ans = min(ans, max(max(i, j), S - i - j));
}
}
}
cout << ans << endl;
return 0;
}
|
In the Jambo Amusement Garden (JAG), you sell colorful drinks consisting of multiple color layers. This colorful drink can be made by pouring multiple colored liquids of different density from the bottom in order.
You have already prepared several colored liquids with various colors and densities. You will receive a drink request with specified color layers. The colorful drink that you will serve must satisfy the following conditions.
* You cannot use a mixed colored liquid as a layer. Thus, for instance, you cannot create a new liquid with a new color by mixing two or more different colored liquids, nor create a liquid with a density between two or more liquids with the same color by mixing them.
* Only a colored liquid with strictly less density can be an upper layer of a denser colored liquid in a drink. That is, you can put a layer of a colored liquid with density $x$ directly above the layer of a colored liquid with density $y$ if $x < y$ holds.
Your task is to create a program to determine whether a given request can be fulfilled with the prepared colored liquids under the above conditions or not.
Input
The input consists of a single test case in the format below.
$N$
$C_1$ $D_1$
$\vdots$
$C_N$ $D_N$
$M$
$O_1$
$\vdots$
$O_M$
The first line consists of an integer $N$ ($1 \leq N \leq 10^5$), which represents the number of the prepared colored liquids. The following $N$ lines consists of $C_i$ and $D_i$ ($1 \leq i \leq N$). $C_i$ is a string consisting of lowercase alphabets and denotes the color of the $i$-th prepared colored liquid. The length of $C_i$ is between $1$ and $20$ inclusive. $D_i$ is an integer and represents the density of the $i$-th prepared colored liquid. The value of $D_i$ is between $1$ and $10^5$ inclusive. The ($N+2$)-nd line consists of an integer $M$ ($1 \leq M \leq 10^5$), which represents the number of color layers of a drink request. The following $M$ lines consists of $O_i$ ($1 \leq i \leq M$). $O_i$ is a string consisting of lowercase alphabets and denotes the color of the $i$-th layer from the top of the drink request. The length of $O_i$ is between $1$ and $20$ inclusive.
Output
If the requested colorful drink can be served by using some of the prepared colored liquids, print 'Yes'. Otherwise, print 'No'.
Examples
Input
2
white 20
black 10
2
black
white
Output
Yes
Input
2
white 10
black 10
2
black
white
Output
No
Input
2
white 20
black 10
2
black
orange
Output
No
Input
3
white 10
red 20
white 30
3
white
red
white
Output
Yes
Input
4
red 3444
red 3018
red 3098
red 3319
4
red
red
red
red
Output
Yes
|
#include<iostream>
#include<map>
#include<algorithm>
#include<queue>
using namespace std;
int n,m;
map<string,priority_queue<int,vector<int>,greater<int> > >M;
int main()
{
cin>>n;
for(int i=0;i<n;i++)
{
string s;int a;cin>>s>>a;
M[s].push(a);
}
cin>>m;
int now=0;
for(;m--;)
{
string s;cin>>s;
while(M[s].size()>0&&M[s].top()<=now)M[s].pop();
if(M[s].size()>0)
{
now=M[s].top();
M[s].pop();
}
else
{
cout<<"No"<<endl;
return 0;
}
}
cout<<"Yes"<<endl;
}
|
Problem
One day, Kawabayashi is about to have lunch at the school cafeteria. There are three types of daily lunch menus for school cafeterias: A lunch, B lunch, and C lunch.
Kawabayashi is a glutton, so I would like to eat all three types of daily lunch menus one by one.
However, Kawabayashi decided to put up with one type of lunch menu and eat two different types of lunch menus so as to minimize the total calorie intake with care for his health.
Ask for a lunch menu that Kawabayashi will endure when given the calories of A, B, and C lunches one day.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a, b, c \ leq 5000 $
* $ a \ neq b, b \ neq c, c \ neq a $
Input
The input is given in the following format.
$ a $ $ b $ $ c $
Three integers $ a $, $ b $, $ c $ are given, separated by spaces. Each represents the calories of A lunch, B lunch, and C lunch one day.
Output
Output the menu name that Kawabayashi will endure on one line.
"A" to put up with A lunch
"B" to put up with B lunch
"C" to put up with C lunch
Output.
Examples
Input
1000 900 850
Output
A
Input
1000 800 1200
Output
C
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if(a > b && a > c) cout << "A" << endl;
else if(b > c) cout << "B" << endl;
else cout << "C" << endl;
return 0;
}
|
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
0 0 3 4
1
2 5
output:
3.1200000000 4.1600000000
"""
import sys
class Segment(object):
__slots__ = ('source', 'target')
def __init__(self, source, target):
self.source = complex(source)
self.target = complex(target)
def dot(a, b):
return a.real * b.real + a.imag * b.imag
def project(s, p):
base_vector = s.target - s.source
prj_ratio = dot(p - s.source, base_vector) / pow(abs(base_vector), 2)
return s.source + base_vector * prj_ratio
def solve(_prj_points):
for point in _prj_points:
xp, yp = map(int, point)
p = xp + yp * 1j
prj = project(prj_segment, p)
print('{real:.10f} {imag:.10f}'.format(real=prj.real, imag=prj.imag))
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
line = tuple(map(int, _input[0].split()))
p1, p2 = (x + y * 1j for x, y in zip(line[::2], line[1::2]))
prj_segment = Segment(p1, p2)
q_num = int(_input[1])
prj_points = map(lambda x: x.split(), _input[2:])
solve(prj_points)
|
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
|
#include <bits/stdc++.h>
#define ull unsigned long long
#define ll long long
#define il inline
#define db double
#define ls rt << 1
#define rs rt << 1 | 1
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
#define X first
#define Y second
#define pcc pair<char, char>
#define vi vector<int>
#define vl vector<ll>
#define rep(i, x, y) for(int i = x; i <= y; i ++)
#define rrep(i, x, y) for(int i = x; i >= y; i --)
#define rep0(i, n) for(int i = 0; i < (n); i ++)
#define per0(i, n) for(int i = (n) - 1; i >= 0; i --)
#define ept 1e-9
#define INF 0x3f3f3f3f
#define sz(x) (x).size()
#define All(x) (x).begin(), (x).end()
#define lowbit(x) ((x) & -(x))
using namespace std;
inline int read()
{
int x = 0, f = 1; char ch = getchar();
while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar(); }
while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
return x * f;
}
inline ll read1()
{
ll x = 0, f = 1; char ch = getchar();
while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar(); }
while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
return x * f;
}
const ll mod = 1e9 + 7;
const int N = 4e6 + 10;
const db pi = acos(-1);
priority_queue<int> a[1010];
int main()
{
int n = read();
int Q = read();
while(Q --)
{
int op = read();
if(op == 0) {int x = read();a[x].push(read());}
if(op == 1)
{
int x = read();
if(a[x].size() != 0) printf("%d\n", a[x].top());
}
if(op == 2)
{
int x = read();
if(a[x].size() != 0) a[x].pop();
}
}
return 0;
}
|
Nanu, a Clash of Clans player is so much obsessed with the game and its new update.
She wants to win as much battles as she can. Each of the enemy clan has N troops of lowercase letters.
And for the attack she takes an army of length M.
In the new update win is given when first k troops she takes, can kill any of the k consecutive troops of the clan.
Remember a troop of type 'a' can only kill a troop of type 'a' in this new update.
Input:
The first line of input contains a single integer T denoting the number of test cases.
The second line contains N, M and k.
Next two lines contains the string of troops length N and M respectively of lowercase letters.
Output:
For each test case, output the number of wins she is going to take at the end of the day. Print -1 if he can't win.
Constraints and Example
Input:
2
5 2 2
abcab
ab
5 2 1
abccc
cc
Output:
2
3
Explanation:
For the first test case, 2 starting troop of ab i.e. ab can kill 2 consecutive troops if placed at 1st and 4th position.
For the second test case, 1 starting troop of cc i.e. c can kill 3 consecutive troops if placed at 3rd, 4th and 5th position.
|
from sys import stdin, stdout
t = int(stdin.readline())
while t:
t -= 1
n, m, k = map(int, stdin.readline().strip().split(' '))
N = stdin.readline().strip()
M = stdin.readline().strip()
M = M[:k]
count = 0
for i in range(len(N)-k+1):
s = N[i:i+k]
if s == M:
count += 1
if count == 0:
count = -1
stdout.write(str(count)+'\n')
|
The captain of the ship TITANIC is a little .... off the track. He needs to select the crew for the ship. But everyone seems to be eligible. So to test their intelligence, he plays a game.
The contestants have to stand in a line. They are given the numbers in the order in which they stand, starting from 1. The captain then removes all the contestants that are standing at an odd position.
Initially, standing people have numbers - 1,2,3,4,5...
After first pass, people left are - 2,4,...
After second pass - 4,....
And so on.
You want to board the ship as a crew member. Given the total number of applicants for a position, find the best place to stand in the line so that you are selected.
Input
First line contains the number of test cases t (t ≤ 10^5). The next t lines contain integer n, the number of applicants for that case. (n ≤ 10^9)
Output
Display t lines, each containg a single integer, the place where you would stand to win a place at TITANIC.
Example
Input:
2
5
12
Output:
4
8
|
from math import floor
from math import log
n = int(raw_input());
while n > 0:
no = int(raw_input());
print int(2**floor(log(no, 2)));
n -= 1;
|
Freakin' news has recently claimed that they have discovered a civilization on mars and that they have established contact with the martians. Following is a summary of the dawn hour breakin' news on freakin' news :
Occassionally, the martian ministers feel the need to please their king. For this purpose, they give the king a trivial problem to solve and heap excessive praise upon him when he presents the correct solution.
This time they have given the king the following problem :
Given two positive integers n,k and n numbers a[1],a[2],...a[n] find the maximum of (b[1]a[1]+b[2]a[2]+.....b[n]a[n]) subject to the restrictions :
1) b[i] is either 1 or (-1), for all i, 1 ≤ i ≤ n.
2) Exactly k b[i]'s are 1. The remaining (n-k) b[i]'s are (-1).
To make the task even easier for the king, the ministers have given the king the sequence a[1],a[2],...a[n] sorted in non-decreasing order.
The king, being lazy, has outsourced the task to freakin' news. Your job is to do this task for freakin' news.
Input Format :
The first line of input contains a single integer n. The next line consists of n space seperated integers a[1], a[2], ... a[n]. The sequence a is guaranteed to be sorted in non-decreasing order.
Output Format :
On the only line of output, output a single integer : the maximum of (b[1]a[1]+b[2]a[2]+.....b[n]a[n]) subject to restrictions 1 and 2.
Constraints :
2 ≤ n ≤ 100
0 ≤ k ≤ n
|a[i]| ≤ 1000
The sequence a is sorted in non-decreasing order i.e. a[1] ≤ a[2] ≤ .... ≤ a[n]
Sample Input :
2 1
-4 -4
Sample Output :
0
Sample Input :
2 0
-2 5
Sample Output :
-3
Explanation :
1 : There are two possibilities for the sequence b : (+1,-1) and (-1,+1). Both lead to sum 0.
2 : There is only one possibility for the sequence b : (-1,-1). This leads to the sum -3.
|
l = raw_input().split()
n, k = int(l[0]), int(l[1])
l = raw_input().split()
l = [int(i) for i in l]
a, b = 1, -1
ans = -1*sum(l[:n-k])+sum(l[n-k:])
print ans
|
There is a line with 1000 cells numbered from 1 to 1000 from left to right and N coins placed on it. Coin i is placed at cell Xi, and no two coins are placed at the same cell.
Bob would like to move the coins to the N leftmost cells of the line. To do this, he is allowed to take a coin from any cell T and move it to cell T-j, where j is an integer between 1 and K, inclusive. This action is possible only if:
cell T-j actually exists and doesn't contain a coin;
each of the cells T-j+1, ..., T-1 contains a coin.
One coin movement takes exactly one second. Find the smallest time in which Bob can achieve his goal.
Input
The first line of the input file contains one integer T -- the number of test cases (no more than 10). Then T test cases follow, and every test case is described by two lines: the first of them contains two integers N and K (1 <= N, K <= 1000), the second of them contains N integers X1, ..., XN in strictly increasing order (1 <= Xi <= 1000).
Output
For each test case output one line containing the requested minimal time for Bob to put all the coins to the left side of the line.
Example
Input:
2
3 2
2 4 7
5 3
1 2 3 4 5
Output:
5
0
Explanation:
In the first example Bob can move the coin from cell 7 consequently to cells 6, 5, 3 and 1, then move the coin from cell 4 to cell 3. In the second example there is nothing to move.
|
for _ in xrange(int(raw_input())):
N, K = map(int, raw_input().split())
coins = map(int, raw_input().split())
if coins[-1] == N:
print 0
continue
seconds = 0
count = 0
for __ in xrange(coins[-1], 0, -1):
if __ in coins:
count += 1
else:
seconds += ((count - 1) / K + 1)
print seconds
|
You are playing following game: given an array A of N natural numbers. All numbers in the array A are at most M. On every turn you may pick any two different elements Ai and Aj (i≠j), such that Ai, Aj ≤ M, and add K to both. The game ends when you are not able to continue. That is, when there is no pair (i,j) left such that both of them are less than equal to M.
Let's call two arrays different if the sum of all their elements is different. When the game ends, you note down the final array A. How many different final arrays can you have.
Input
The first line contains three integers N, M and K. N elements of the array follow in the next line.
Output
Output single integer - answer for the given problem modulo 10^9+7.
Constraints
1 ≤ N ≤ 10^5
1 ≤ M,K ≤ 10^12
1 ≤ Ai ≤ M
Example
Input:
3 3 2
1 2 3
Output:
2
Explanation
All possible sums are 14 and 10. You can get them by, for example, these arrays:
A=(5, 4, 5),
A=(1, 4, 5)
The above arrays are different because their sums are different.
|
import sys
N, M, K = map(lambda x: int(x), sys.stdin.readline().split())
A = map(lambda x: int(x), sys.stdin.readline().split())
moves = map(lambda x: (M - x) / K + 1, A)
moves_sum = sum(moves)
moves_max = max(moves)
moves.remove(moves_max)
moves_max2 = max(moves)
min_moves = max((moves_sum - moves_max + 1) / 2, moves_max2)
max_moves = min(moves_sum / 2, moves_sum - moves_max)
print (max_moves - min_moves + 1) % (10 ** 9 + 7)
|
Witua is a little student from the University of Lviv. He enjoys studying math. Witua knows a lot of famous mathematicians like Eratosthenes, Pythagoras, Fermat, Diophantus, Furko, Gauss and so on. However, his favorite one is Euler. The only thing Witua likes more than Euler is Euler’s totient function φ. He is exploring the nature of this function. One of the steps of his work is finding φ(i)/i for all 2≤i≤N. He doesn’t need to know every such value, but Witua wonders for what value i, is φ(i)/i the maximum he can get? Help little student to find such i that φ(i)/i is maximum among all the 2≤i≤N.
Input
The first line contains single integer T - the number of test cases. Each of the next T lines contains a single integer N.
Output
For every test case output i such that φ(i)/i is maximum among all i (2≤i≤N) in a separate line.
Constrains
T (1≤T≤500 )
N(2≤N≤10^18)
Example
Input:
3
2
3
4
Output:
2
3
3
Explanation
φ(2)/2=1/2
φ(3)/3=2/3
φ(4)/4=2/4
|
import random
def modulo(a,b,c):
x = 1
y = a
while b>0:
if b%2==1:
x = (x*y)%c
y = (y*y)%c
b = b/2
return x%c
def millerRabin(N,iteration):
if N<2:
return 0
if N!=2 and N%2==0:
return 0
d=N-1
while d%2==0:
d = d/2
for i in range(iteration):
a = random.randint(1, N-1)
temp = d
x = modulo(a,temp,N)
while (temp!=N-1 and x!=1 and x!=N-1):
x = (x*x)%N
temp = temp*2
if (x!=N-1 and temp%2==0):
return 0
return 1
class witmath:
def test(self):
t=input()
array=[]
for j in range(t):
n=input()
k=n
if k%2==0 and k>3:
k=k-1
while 1:
x=millerRabin(k,5)
if (x==1):
break
if (x==0):
k=k-1
continue
print k
wit=witmath()
wit.test()
|
In Summer Informatics School, if a student doesn't behave well, teachers make a hole in his badge. And today one of the teachers caught a group of n students doing yet another trick.
Let's assume that all these students are numbered from 1 to n. The teacher came to student a and put a hole in his badge. The student, however, claimed that the main culprit is some other student p_a.
After that, the teacher came to student p_a and made a hole in his badge as well. The student in reply said that the main culprit was student p_{p_a}.
This process went on for a while, but, since the number of students was finite, eventually the teacher came to the student, who already had a hole in his badge.
After that, the teacher put a second hole in the student's badge and decided that he is done with this process, and went to the sauna.
You don't know the first student who was caught by the teacher. However, you know all the numbers p_i. Your task is to find out for every student a, who would be the student with two holes in the badge if the first caught student was a.
Input
The first line of the input contains the only integer n (1 ≤ n ≤ 1000) — the number of the naughty students.
The second line contains n integers p_1, ..., p_n (1 ≤ p_i ≤ n), where p_i indicates the student who was reported to the teacher by student i.
Output
For every student a from 1 to n print which student would receive two holes in the badge, if a was the first student caught by the teacher.
Examples
Input
3
2 3 2
Output
2 2 3
Input
3
1 2 3
Output
1 2 3
Note
The picture corresponds to the first example test case.
<image>
When a = 1, the teacher comes to students 1, 2, 3, 2, in this order, and the student 2 is the one who receives a second hole in his badge.
When a = 2, the teacher comes to students 2, 3, 2, and the student 2 gets a second hole in his badge. When a = 3, the teacher will visit students 3, 2, 3 with student 3 getting a second hole in his badge.
For the second example test case it's clear that no matter with whom the teacher starts, that student would be the one who gets the second hole in his badge.
|
#include <bits/stdc++.h>
using namespace std;
void dfs(vector<int> adj[], int i, vector<bool> &vis) {
vis[i] = 1;
for (auto it : adj[i]) {
if (!vis[it])
dfs(adj, it, vis);
else {
cout << it << " ";
return;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
vector<int> adj[n + 1];
for (int i = 1; i < n + 1; i = i + 1) {
int x;
cin >> x;
adj[i].push_back(x);
}
vector<bool> vis(n + 1, 0);
for (int i = 1; i < n + 1; i = i + 1) {
vis = vector<bool>(n + 1, 0);
dfs(adj, i, vis);
}
return 0;
}
|
Zibi is a competitive programming coach. There are n competitors who want to be prepared well. The training contests are quite unusual – there are two people in a team, two problems, and each competitor will code exactly one of them. Of course, people in one team will code different problems.
Rules of scoring also aren't typical. The first problem is always an implementation problem: you have to implement some well-known algorithm very fast and the time of your typing is rated. The second one is an awful geometry task and you just have to get it accepted in reasonable time. Here the length and difficulty of your code are important. After that, Zibi will give some penalty points (possibly negative) for each solution and the final score of the team is the sum of them (the less the score is, the better).
We know that the i-th competitor will always have score x_i when he codes the first task and y_i when he codes the second task. We can assume, that all competitors know each other's skills and during the contest distribute the problems in the way that minimizes their final score. Remember that each person codes exactly one problem in a contest.
Zibi wants all competitors to write a contest with each other. However, there are m pairs of people who really don't like to cooperate and they definitely won't write a contest together. Still, the coach is going to conduct trainings for all possible pairs of people, such that the people in pair don't hate each other. The coach is interested for each participant, what will be his or her sum of scores of all teams he trained in?
Input
The first line contains two integers n and m (2 ≤ n ≤ 300 000, 0 ≤ m ≤ 300 000) — the number of participants and the number of pairs of people who will not write a contest together.
Each of the next n lines contains two integers x_i and y_i (-10^9 ≤ x_i, y_i ≤ 10^9) — the scores which will the i-th competitor get on the first problem and on the second problem. It is guaranteed that there are no two people having both x_i and y_i same.
Each of the next m lines contain two integers u_i and v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i) — indices of people who don't want to write a contest in one team. Each unordered pair of indices will appear at most once.
Output
Output n integers — the sum of scores for all participants in the same order as they appear in the input.
Examples
Input
3 2
1 2
2 3
1 3
1 2
2 3
Output
3 0 3
Input
3 3
1 2
2 3
1 3
1 2
2 3
1 3
Output
0 0 0
Input
5 3
-1 3
2 4
1 1
3 5
2 2
1 4
2 3
3 5
Output
4 14 4 16 10
Note
In the first example, there will be only one team consisting of persons 1 and 3. The optimal strategy for them is to assign the first task to the 3-rd person and the second task to the 1-st person, this will lead to score equal to 1 + 2 = 3.
In the second example, nobody likes anyone, so there won't be any trainings. It seems that Zibi won't be titled coach in that case...
|
import sys
s = sys.stdin.read()
n = m = -1
numb = 0
for i in range(len(s)):
if ord(s[i])>=48:
numb = 10*numb + ord(s[i])-48
else:
if n==-1:
n = numb
else:
m = numb
break
numb = 0
inp = []
numb = 0
sign = 1
for i in range(i+1,len(s)):
if ord(s[i])>=48:
numb = 10*numb + ord(s[i])-48
else:
if ord(s[i])==45:
sign = -1
else:
inp.append(sign*numb)
numb = 0
sign = 1
if ord(s[-1])>=48:
inp.append(sign*numb)
order = sorted(range(n),key=lambda i:inp[2*i]-inp[2*i+1])
score = [0]*n
val = sum(inp[1:2*n:2])
for ind in range(n):
i = order[ind]
# Do second problem together with order[:ind]
# Do first problem together with order[ind:]
score[i] += val + inp[2*i+1]*(ind-1) + inp[2*i]*(n-ind-1)
val += inp[2*i]-inp[2*i+1]
for _ in range(m):
u = inp[2*n+2*_]-1
v = inp[2*n+2*_+1]-1
s = min(inp[2*u]+inp[2*v+1],inp[2*v]+inp[2*u+1])
score[u] -= s
score[v] -= s
sys.stdout.write(' '.join(str(x) for x in score))
|
You have got a shelf and want to put some books on it.
You are given q queries of three types:
1. L id — put a book having index id on the shelf to the left from the leftmost existing book;
2. R id — put a book having index id on the shelf to the right from the rightmost existing book;
3. ? id — calculate the minimum number of books you need to pop from the left or from the right in such a way that the book with index id will be leftmost or rightmost.
You can assume that the first book you will put can have any position (it does not matter) and queries of type 3 are always valid (it is guaranteed that the book in each such query is already placed). You can also assume that you don't put the same book on the shelf twice, so ids don't repeat in queries of first two types.
Your problem is to answer all the queries of type 3 in order they appear in the input.
Note that after answering the query of type 3 all the books remain on the shelf and the relative order of books does not change.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.
Then q lines follow. The i-th line contains the i-th query in format as in the problem statement. It is guaranteed that queries are always valid (for query type 3, it is guaranteed that the book in each such query is already placed, and for other types, it is guaranteed that the book was not placed before).
It is guaranteed that there is at least one query of type 3 in the input.
In each query the constraint 1 ≤ id ≤ 2 ⋅ 10^5 is met.
Output
Print answers to queries of the type 3 in order they appear in the input.
Examples
Input
8
L 1
R 2
R 3
? 2
L 4
? 1
L 5
? 1
Output
1
1
2
Input
10
L 100
R 100000
R 123
L 101
? 123
L 10
R 115
? 100
R 110
? 115
Output
0
2
1
Note
Let's take a look at the first example and let's consider queries:
1. The shelf will look like [1];
2. The shelf will look like [1, 2];
3. The shelf will look like [1, 2, 3];
4. The shelf looks like [1, 2, 3] so the answer is 1;
5. The shelf will look like [4, 1, 2, 3];
6. The shelf looks like [4, 1, 2, 3] so the answer is 1;
7. The shelf will look like [5, 4, 1, 2, 3];
8. The shelf looks like [5, 4, 1, 2, 3] so the answer is 2.
Let's take a look at the second example and let's consider queries:
1. The shelf will look like [100];
2. The shelf will look like [100, 100000];
3. The shelf will look like [100, 100000, 123];
4. The shelf will look like [101, 100, 100000, 123];
5. The shelf looks like [101, 100, 100000, 123] so the answer is 0;
6. The shelf will look like [10, 101, 100, 100000, 123];
7. The shelf will look like [10, 101, 100, 100000, 123, 115];
8. The shelf looks like [10, 101, 100, 100000, 123, 115] so the answer is 2;
9. The shelf will look like [10, 101, 100, 100000, 123, 115, 110];
10. The shelf looks like [10, 101, 100, 100000, 123, 115, 110] so the answer is 1.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner();
HashMap<Integer,Long> map=new HashMap<>();
int n = Integer.parseInt(sc.next());
long der=0; long izq=0;
for (int i = 0; i < n; i++) {
String s=sc.next();
int x=Integer.parseInt(sc.next());
if(i==0){
map.put(x, izq);
}else{
if(s.equals("L")){
izq--;
map.put(x, izq);
}else if(s.equals("R")){
der++;
map.put(x, der);
}else{
long w=map.get(x);
System.out.println(Math.min(Math.abs(der-w),Math.abs(izq-w)));
}
}
}
}
static class Scanner {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
int spaces = 0;
public String nextLine() throws IOException {
if (spaces-- > 0) {
return "";
} else if (st.hasMoreTokens()) {
return new StringBuilder(st.nextToken("\n")).toString();
}
return br.readLine();
}
public String next() throws IOException {
spaces = 0;
while (!st.hasMoreTokens()) {
st = new StringTokenizer(br.readLine());
}
return st.nextToken();
}
public boolean hasNext() throws IOException {
while (!st.hasMoreTokens()) {
String line = br.readLine();
if (line == null) {
return false;
}
if (line.equals("")) {
spaces = Math.max(spaces, 0) + 1;
}
st = new StringTokenizer(line);
}
return true;
}
}
}
|
You are given a positive integer n.
Find a sequence of fractions (a_i)/(b_i), i = 1 … k (where a_i and b_i are positive integers) for some k such that:
$$$ \begin{cases} $b_i$ divides $n$, $1 < b_i < n$ for $i = 1 … k$ \\\ $1 ≤ a_i < b_i$ for $i = 1 … k$ \\\ \text{$∑_{i=1}^k (a_i)/(b_i) = 1 - 1/n$} \end{cases} $$$
Input
The input consists of a single integer n (2 ≤ n ≤ 10^9).
Output
In the first line print "YES" if there exists such a sequence of fractions or "NO" otherwise.
If there exists such a sequence, next lines should contain a description of the sequence in the following format.
The second line should contain integer k (1 ≤ k ≤ 100 000) — the number of elements in the sequence. It is guaranteed that if such a sequence exists, then there exists a sequence of length at most 100 000.
Next k lines should contain fractions of the sequence with two integers a_i and b_i on each line.
Examples
Input
2
Output
NO
Input
6
Output
YES
2
1 2
1 3
Note
In the second example there is a sequence 1/2, 1/3 such that 1/2 + 1/3 = 1 - 1/6.
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie();
int n;
cin >> n;
int p = n;
for (long long i = 2; i * i < n; ++i) {
n = p;
if (n % i == 0) {
long long d1 = 1;
while (n % i == 0) {
n /= i;
d1 *= i;
}
if (n == 1) {
cout << "NO";
return 0;
}
long long d2 = p / d1;
for (long long a = 1; a < d2; ++a) {
if (p - 1 - a * d1 > 0) {
if ((p - 1 - a * d1) % d2 == 0) {
cout << "YES" << '\n' << 2 << '\n';
cout << a << ' ' << d2 << '\n';
cout << (p - 1 - a * d1) / d2 << ' ' << d1 << '\n';
return 0;
}
}
}
}
}
cout << "NO";
return 0;
}
|
You are given two segments [l_1; r_1] and [l_2; r_2] on the x-axis. It is guaranteed that l_1 < r_1 and l_2 < r_2. Segments may intersect, overlap or even coincide with each other.
<image> The example of two segments on the x-axis.
Your problem is to find two integers a and b such that l_1 ≤ a ≤ r_1, l_2 ≤ b ≤ r_2 and a ≠ b. In other words, you have to choose two distinct integer points in such a way that the first point belongs to the segment [l_1; r_1] and the second one belongs to the segment [l_2; r_2].
It is guaranteed that the answer exists. If there are multiple answers, you can print any of them.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 500) — the number of queries.
Each of the next q lines contains four integers l_{1_i}, r_{1_i}, l_{2_i} and r_{2_i} (1 ≤ l_{1_i}, r_{1_i}, l_{2_i}, r_{2_i} ≤ 10^9, l_{1_i} < r_{1_i}, l_{2_i} < r_{2_i}) — the ends of the segments in the i-th query.
Output
Print 2q integers. For the i-th query print two integers a_i and b_i — such numbers that l_{1_i} ≤ a_i ≤ r_{1_i}, l_{2_i} ≤ b_i ≤ r_{2_i} and a_i ≠ b_i. Queries are numbered in order of the input.
It is guaranteed that the answer exists. If there are multiple answers, you can print any.
Example
Input
5
1 2 1 2
2 6 3 4
2 4 1 3
1 2 1 3
1 4 5 8
Output
2 1
3 4
3 2
1 2
3 7
|
qry=int(input())
for _ in range(qry):
lrs=list(map(int,input().split()))
if lrs[0]==lrs[2]:
print(lrs[0],lrs[3])
else:
print(lrs[0],lrs[2])
|
In the country N, there are n cities connected by m one-way roads. Although this country seems unremarkable, there are two interesting facts about it. At first, a week lasts d days here. At second, there is exactly one museum in each city of the country N.
Travel agency "Open museums" is developing a new program for tourists interested in museums. Agency's employees know which days each of the museums is open. The tour should start in the capital — the city number 1, and the first day of the tour must be on the first day of a week. Each day a tourist will be in some city, watching the exposition in its museum (in case museum is open today), and by the end of the day, the tour either ends or the tourist goes into another city connected by a road with the current one. The road system of N is designed in such a way that traveling by a road always takes one night and also all the roads are one-way. It's allowed to visit a city multiple times during the trip.
You should develop such route for the trip that the number of distinct museums, possible to visit during it, is maximum.
Input
The first line contains three integers n, m and d (1 ≤ n ≤ 100 000, 0 ≤ m ≤ 100 000, 1 ≤ d ≤ 50), the number of cities, the number of roads and the number of days in a week.
Each of next m lines contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i), denoting a one-way road from the city u_i to the city v_i.
The next n lines contain the museums' schedule. The schedule of the museum located in the i-th city is described in the i-th of these lines. Each line consists of exactly d characters "0" or "1", the j-th character of the string equals to "1" if the museum is open at the j-th day of a week, and "0", otherwise.
It's guaranteed that for each pair of cities (u, v) there exists no more than one road leading from u to v.
Output
Print a single integer — the maximum number of distinct museums, that it's possible to visit, starting a trip in the first city on the first day of the week.
Examples
Input
4 5 3
3 1
1 2
2 4
4 1
2 3
011
110
111
001
Output
3
Input
3 3 7
1 2
1 3
2 3
1111111
0000000
0111111
Output
2
Note
Explanation of the first example <image>
The maximum number of distinct museums to visit is 3. It's possible to visit 3 museums, for example, in the way described below.
* Day 1. Now it's the 1st day of a week, and the tourist is in the city 1. The museum there is closed. At night the tourist goes to the city number 2.
* Day 2. Now it's the 2nd day of a week, and the tourist is in the city 2. The museum there is open, and the tourist visits it. At night the tourist goes to the city number 4.
* Day 3. Now it's the 3rd day of a week, and the tourist is in the city 4. The museum there is open, and the tourist visits it. At night the tourist goes to the city number 1.
* Day 4. Now it's the 1st day of a week, and the tourist is in the city 1. The museum there is closed. At night the tourist goes to the city number 2.
* Day 5. Now it's the 2nd of a week number 2, and the tourist is in the city 2. The museum there is open, but the tourist has already visited it. At night the tourist goes to the city number 3.
* Day 6. Now it's the 3rd day of a week, and the tourist is in the city 3. The museum there is open, and the tourist visits it. After this, the tour is over.
Explanation of the second example <image>
The maximum number of distinct museums to visit is 2. It's possible to visit 2 museums, for example, in the way described below.
* Day 1. Now it's the 1st day of a week, and the tourist is in the city 1. The museum there is open, and the tourist visits it. At night the tourist goes to the city number 2.
* Day 2. Now it's the 2nd day of a week, and the tourist is in the city 2. The museum there is closed. At night the tourist goes to the city number 3.
* Day 3. Now it's the 3rd day of a week, and the tourist is in the city 3. The museum there is open, and the tourist visits it. After this, the tour is over.
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class C {
static PrintWriter out = new PrintWriter(System.out);
/*
3 3 7
1 2
1 3
2 3
0111111
0000000
0111111
*/
static int N, M, D;
static SCC g, rev;
static boolean open[][];
static int[] map, rep, distToRep, distFromRep;
static int[][] getIfHereAtD;
static int[] cycGcd;
static int dp[][];
public static void main(String[] args) {
FS in = new FS();
N = in.nextInt();
M = in.nextInt();
D = in.nextInt();
g = new SCC(N);
rev = new SCC(N);
for(int i = 0; i < M; i++) {
int a = in.nextInt()-1, b = in.nextInt()-1;
g.add(a, b);
rev.add(b, a);
}
open = new boolean[N][D];
for(int i = 0; i < N; i++) {
char c[] = in.next().toCharArray();
for(int j = 0; j < D; j++) open[i][j] = c[j] == '1';
}
map = g.go();
// Set up dists to rep
rep = new int[N];
distToRep = new int[N];
Arrays.fill(distToRep, -1);
distFromRep = new int[N];
Arrays.fill(distFromRep, -1);
for(int i = 0; i < N; i++) {
if(distToRep[i] == -1) {
rep[i] = i;
distToRep[i] = 0;
distFromRep[i] = 0;
ArrayDeque<Integer> q = new ArrayDeque<Integer>();
q.add(i);
while(!q.isEmpty()) {
int v = q.poll();
for(int ii : rev.adj[v]) {
if(map[ii] != map[v] || distToRep[ii] != -1) continue;
distToRep[ii] = 1+distToRep[v];
rep[ii] = rep[v];
q.add(ii);
}
}
q.add(i);
while(!q.isEmpty()) {
int v = q.poll();
for(int ii : g.adj[v]) {
if(map[ii] != map[v] || distFromRep[ii] != -1) continue;
distFromRep[ii] = 1+distFromRep[v];
q.add(ii);
}
}
}
}
getIfHereAtD = new int[N][D];
for(int a[] : getIfHereAtD) Arrays.fill(a, -1);
boolean seen[][] = new boolean[N][D];
boolean taken[] = new boolean[N];
cycGcd = new int[N];
for(int i = 0; i < N; i++) {
if(rep[i] == i) {
// calc for this guy
ArrayDeque<Integer> dsHave = new ArrayDeque<Integer>();
ArrayDeque<Integer> revTaken = new ArrayDeque<Integer>();
ArrayDeque<Integer> q = new ArrayDeque<Integer>();
for(int d = 0; d < D; d++) {
if(getIfHereAtD[i][d] != -1) continue; //already calc'd
int cnt = 0;
q.add(i); q.add(d);
seen[i][d] = true;
if(open[i][d]) {taken[i] = true; revTaken.add(i); cnt++;}
while(!q.isEmpty()) {
int n = q.poll();
int curD = q.poll();
if(n == i) dsHave.add(curD);
for(int ii : g.adj[n]) {
if(map[n] != map[ii]) continue;
int newD = (curD == D-1 ? 0 : curD+1);
if(seen[ii][newD]) continue;
seen[ii][newD] = true;
q.add(ii); q.add(newD);
if(!taken[ii] && open[ii][newD]) { taken[ii] = true; revTaken.add(ii); cnt++;}
}
}
int smallestNonZero = D;
while(!dsHave.isEmpty()) {
int nd = dsHave.poll();
getIfHereAtD[i][nd] = cnt;
if(nd > 0) smallestNonZero = Math.min(smallestNonZero, nd);
}
while(!revTaken.isEmpty()) taken[revTaken.poll()] = false;
if(d == 0) {
cycGcd[i] = smallestNonZero;
}
}
}
}
dp = new int[D][N];
for(int a[] : dp) Arrays.fill(a, -1);
int res = go(0, 0);
out.println(res);
out.close();
}
static int go(int d, int n) {
d = (d + distToRep[n])%D;
n = rep[n];
if(dp[d][n] != -1) return dp[d][n];
int res = getIfHereAtD[n][d];
int gain = 0;
// try transition
int newD = d;
do {
for(int ii : g.comp[map[n]]) {
int nextD = (newD + distFromRep[ii] + 1)%D;
for(int to : g.adj[ii]) {
if(map[ii] == map[to]) continue;
gain = Math.max(gain, go(nextD, to));
}
}
newD = (newD + cycGcd[n])%D;
} while(newD != d);
return dp[d][n] = res + gain;
}
static class SCC {
ArrayList<Integer>[] adj, comp;
int n, idx, cs;
boolean[] u;
int[] pre,low,map;
ArrayDeque<Integer> s;
public SCC(int nn) {
adj = new ArrayList[n=nn];
for(int i = 0; i < n; i++) adj[i] = new ArrayList<>();
}
void add(int a, int b) {
adj[a].add(b);
}
int[] go() {
comp = new ArrayList[n];
idx = 1; cs = 0;
pre = new int[n]; low = new int[n]; map = new int[n];
u = new boolean[n];
s = new ArrayDeque<Integer>();
for(int i = 0; i < n; i++)
if(pre[i] == 0) dfs(i);
return map;
}
void dfs(int v) {
pre[v] = low[v] = idx++;
s.push(v);;
u[v] = true;
for(int to : adj[v]) {
if(pre[to] == 0) {
dfs(to);
low[v] = Math.min(low[v], low[to]);
} else if(u[to]) {
low[v] = Math.min(low[v], pre[to]);
}
}
if(low[v] == pre[v]) {
int next;
comp[cs] = new ArrayList<>();
do {
next = s.pop();
u[next] = false;
map[next] = cs;
comp[cs].add(next);
} while(next != v);
cs++;
}
}
}
static class FS{
BufferedReader br;
StringTokenizer st;
public FS() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while(st == null || !st.hasMoreElements()) {
try {st = new StringTokenizer(br.readLine());}
catch(Exception e) { throw null;}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next());}
double nextDouble() { return Double.parseDouble(next());}
long nextLong() { return Long.parseLong(next());}
int[] NIA(int n) {
int r[] = new int[n];
for(int i = 0; i < n; i++) r[i] = nextInt();
return r;
}
long[] NLA(int n) {
long r[] = new long[n];
for(int i = 0; i < n; i++) r[i] = nextLong();
return r;
}
char[][] grid(int r, int c){
char res[][] = new char[r][c];
for(int i = 0; i < r; i++) {
char l[] = next().toCharArray();
for(int j = 0; j < c; j++) {
res[i][j] = l[j];
}
}
return res;
}
}
}
|
Jury picked a polynomial f(x) = a_0 + a_1 ⋅ x + a_2 ⋅ x^2 + ... + a_k ⋅ x^k. k ≤ 10 and all a_i are integer numbers and 0 ≤ a_i < 10^6 + 3. It's guaranteed that there is at least one i such that a_i > 0.
Now jury wants you to find such an integer x_0 that f(x_0) ≡ 0 mod (10^6 + 3) or report that there is not such x_0.
You can ask no more than 50 queries: you ask value x_q and jury tells you value f(x_q) mod (10^6 + 3).
Note that printing the answer doesn't count as a query.
Interaction
To ask a question, print "? x_q" (0 ≤ x_q < 10^6 + 3). The judge will respond with a single integer f(x_q) mod (10^6 + 3). If you ever get a result of −1 (because you printed an invalid query), exit immediately to avoid getting other verdicts.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
When you are ready to answer, print "! x_0" where x_0 is the answer or -1 if there is no such x_0.
You can ask at most 50 questions per test case.
Hack Format
To hack, use the following format.
The only line should contain 11 integers a_0, a_1, ..., a_{10} (0 ≤ a_i < 10^6 + 3, max_{0 ≤ i ≤ 10}{a_i} > 0) — corresponding coefficients of the polynomial.
Examples
Input
1000002
0
Output
? 0
? 1
! 1
Input
5
2
1
Output
? 2
? 1
? 0
! -1
Note
The polynomial in the first sample is 1000002 + x^2.
The polynomial in the second sample is 1 + x^2.
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e6 + 3;
long long int query(int x) {
printf("? %d\n", x);
fflush(stdout);
long long int r;
scanf("%lld", &r);
return r;
}
void ex_(long long int x) {
printf("! %lld", x);
exit(0);
}
long long int pows(long long int now, int num) {
if (num == 0) return 1;
if (num == 1) return now;
long long int nn = pows(now, num / 2);
if (num % 2 == 0) return (nn * nn) % mod;
return (((nn * nn) % mod) * now) % mod;
}
long long int dp[11][11], dp2[11], dp3[11];
int main(void) {
for (int e = 0; e <= 10; e++) dp2[e] = (query(e));
dp[0][0] = 1;
for (int e = 1; e <= 10; e++) {
long long int x = 1;
for (int p = 0; p <= 10; p++) {
dp[e][p] = x;
x = (x * (long long int)e) % mod;
}
}
for (int e = 0; e <= 10; e++) {
for (int p = 10; p > e; p--) {
for (int r = e + 1; r <= 10; r++) {
dp[p][r] = (dp[p][r] - dp[p - 1][r] + mod) % mod;
}
dp2[p] = (dp2[p] - dp2[p - 1] + mod) % mod;
}
}
long long int x = 1;
for (int e = 1; e <= 10; e++) {
x = (x * (long long int)e) % mod;
dp2[e] = (dp2[e] * pows(x, mod - 2)) % mod;
for (int p = e; p <= 10; p++)
dp[e][p] = (dp[e][p] * pows(x, mod - 2)) % mod;
}
dp3[10] = dp2[10];
for (int e = 9; e >= 0; e--) {
for (int p = 10; p > e; p--) {
dp2[e] = (dp2[e] - (dp[e][p] * dp3[p]) % mod + mod) % mod;
}
dp3[e] = dp2[e];
}
for (int e = 0; e < mod; e++) {
long long int val = 0, x = 1;
for (int p = 0; p <= 10; p++) {
val = (val + (dp3[p] * x) % mod) % mod;
x = (x * (long long int)e) % mod;
}
if (val == 0) {
printf("! %d", e);
return 0;
}
}
printf("! -1");
return 0;
}
|
Recall that string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly zero or all) characters. For example, for the string a="wowwo", the following strings are subsequences: "wowwo", "wowo", "oo", "wow", "", and others, but the following are not subsequences: "owoo", "owwwo", "ooo".
The wow factor of a string is the number of its subsequences equal to the word "wow". Bob wants to write a string that has a large wow factor. However, the "w" key on his keyboard is broken, so he types two "v"s instead.
Little did he realise that he may have introduced more "w"s than he thought. Consider for instance the string "ww". Bob would type it as "vvvv", but this string actually contains three occurrences of "w":
* "vvvv"
* "vvvv"
* "vvvv"
For example, the wow factor of the word "vvvovvv" equals to four because there are four wows:
* "vvvovvv"
* "vvvovvv"
* "vvvovvv"
* "vvvovvv"
Note that the subsequence "vvvovvv" does not count towards the wow factor, as the "v"s have to be consecutive.
For a given string s, compute and output its wow factor. Note that it is not guaranteed that it is possible to get s from another string replacing "w" with "vv". For example, s can be equal to "vov".
Input
The input contains a single non-empty string s, consisting only of characters "v" and "o". The length of s is at most 10^6.
Output
Output a single integer, the wow factor of s.
Examples
Input
vvvovvv
Output
4
Input
vvovooovovvovoovoovvvvovovvvov
Output
100
Note
The first example is explained in the legend.
|
s = input()
n = len(s)
count_o = []
count_w = 0
count = 0
for i in range(1, n):
if s[i] == 'v' and s[i-1] == 'v':
count_w += 1
elif s[i] == 'o':
count_o.append(count_w)
for c in count_o:
count += c * (count_w-c)
print(count)
|
You are given an array a consisting of n integers a_1, a_2, ..., a_n. You want to split it into exactly k non-empty non-intersecting subsegments such that each subsegment has odd sum (i. e. for each subsegment, the sum of all elements that belong to this subsegment is odd). It is impossible to rearrange (shuffle) the elements of a given array. Each of the n elements of the array a must belong to exactly one of the k subsegments.
Let's see some examples of dividing the array of length 5 into 3 subsegments (not necessarily with odd sums): [1, 2, 3, 4, 5] is the initial array, then all possible ways to divide it into 3 non-empty non-intersecting subsegments are described below:
* [1], [2], [3, 4, 5];
* [1], [2, 3], [4, 5];
* [1], [2, 3, 4], [5];
* [1, 2], [3], [4, 5];
* [1, 2], [3, 4], [5];
* [1, 2, 3], [4], [5].
Of course, it can be impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements. In this case print "NO". Otherwise, print "YES" and any possible division of the array. See the output format for the detailed explanation.
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries. Then q queries follow.
The first line of the query contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array and the number of subsegments, respectively.
The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it. If it is impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements, print "NO" in the first line. Otherwise, print "YES" in the first line and any possible division of the array in the second line. The division can be represented as k integers r_1, r_2, ..., r_k such that 1 ≤ r_1 < r_2 < ... < r_k = n, where r_j is the right border of the j-th segment (the index of the last element that belongs to the j-th segment), so the array is divided into subsegments [1; r_1], [r_1 + 1; r_2], [r_2 + 1, r_3], ..., [r_{k - 1} + 1, n]. Note that r_k is always n but you should print it anyway.
Example
Input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2
Output
YES
1 3 5
NO
NO
|
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
PrintWriter out = new PrintWriter(outputStream);
InputReader in = new InputReader(inputStream);
// for(int i=4;i<=4;i++) {
// InputStream uinputStream = new FileInputStream("leftout.in");
// String f = i+".in";
// InputStream uinputStream = new FileInputStream(f);
// InputReader in = new InputReader(uinputStream);
// PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("leftout.out")));
Task t = new Task();
t.solve(in, out);
out.close();
// }
}
static class Task {
public void solve(InputReader in, PrintWriter out) throws IOException {
int c = in.nextInt();
while(c-->0) {
int cnt = 0;
int n = in.nextInt();
int k = in.nextInt();
int odd = 0;
ArrayList<Integer> arr = new ArrayList<Integer>();
for(int i=0;i<n;i++) {
int t = in.nextInt();
if(t%2==1) odd++;
if(cnt<k-1) {
if(odd==1) {
cnt++;
odd = 0;
arr.add(i+1);
}
}
}
if(odd%2==1) {
cnt++;
arr.add(n);
}
if(cnt==k) {
out.println("YES");
for(int i=0;i<arr.size();i++) {
out.print(arr.get(i));
if(i<arr.size()-1) out.print(" ");
}
out.println();
}else{
out.println("NO");
}
}
}
List<List<Integer>> convert(int arr[][]){
int n = arr.length;
List<List<Integer>> ret = new ArrayList<>();
for(int i=0;i<n;i++) {
ArrayList<Integer> tmp = new ArrayList<Integer>();
for(int j=0;j<arr[i].length;j++) tmp.add(arr[i][j]);
ret.add(tmp);
}
return ret;
}
public int maximumSum(int[] arr) {
int n = arr.length;
int dp[][] = new int[n][2];
dp[0][0] = arr[0];
int ret = arr[0];
for(int i=1;i<n;i++) {
dp[i][0] = dp[i-1][0]>=0?(dp[i-1][0]+arr[i]):arr[i];
int t1 = dp[i-1][0];
int t2 = (dp[i-1][1]<0?0:dp[i-1][1])+arr[i];
dp[i][1] = Math.max(t1,t2);
ret = Math.max(ret,Math.max(dp[i][0], dp[i][1]));
}
return ret;
}
public List<Integer> findNumOfValidWords(String[] words, String[] puzzles) {
List<Integer> ret = new ArrayList<Integer>();
HashMap<Integer,Integer>[] mp = new HashMap[26];
for(int i=0;i<26;i++) mp[i] = new HashMap<Integer,Integer>();
//String p = "abcdz";
//Dumper.print(enc(p));
for(int i=0;i<words.length;i++) {
int v = enc(words[i]);
for(int j=0;j<words[i].length();j++) {
mp[words[i].charAt(j)-'a'].put(v, 1);
}
}
for(int i=0;i<puzzles.length;i++) {
int n = puzzles[i].length();
int t = 0;
for(int j=1;j<1<<(n-1);j++) {
int v = 0;
for(int k=0;k<6;k++) {
if((j&(1<<k))!=0) {
v|=(1<<(puzzles[i].charAt(k)-'a'));
}
}
v|=(1<<(puzzles[i].charAt(0)-'a'));
//t+=search(v,mp[puzzles[i].charAt(0)-'a']);
}
ret.add(t);
}
return ret;
}
int search(int x, HashMap<Integer,Integer> mp, HashSet<Integer> hs) {
if(mp.containsKey(x)) return mp.get(x);
if(x==0) return 0;
int v = 0;
for(int i=0;i<7;i++) {
if((x&(1<<i))!=0) {
int t = x;
t^=(1<<i);
if(!hs.contains(t)) {
hs.add(t);
v+=search(t,mp,hs);
}
}
}
mp.put(x, v);
return v;
}
int enc(String x) {
char[] arr = x.toCharArray();
int v = 0;
for(int i=0;i<arr.length;i++) {
v|=1<<(arr[i]-'a');
}
return v;
}
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
public int GCD(int a, int b) {
if (b==0) return a;
return GCD(b,a%b);
}
}
static class ArrayUtils {
static final long seed = System.nanoTime();
static final Random rand = new Random(seed);
public static void sort(int[] a) {
shuffle(a);
Arrays.sort(a);
}
public static void shuffle(int[] a) {
for (int i = 0; i < a.length; i++) {
int j = rand.nextInt(i + 1);
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
}
static class BIT{
int arr[];
int n;
public BIT(int a) {
n=a;
arr = new int[n];
}
int sum(int p) {
int s=0;
while(p>0) {
s+=arr[p];
p-=p&(-p);
}
return s;
}
void add(int p, int v) {
while(p<n) {
arr[p]+=v;
p+=p&(-p);
}
}
}
static class DSU{
int[] arr;
int[] sz;
public DSU(int n) {
arr = new int[n];
sz = new int[n];
for(int i=0;i<n;i++) arr[i] = i;
Arrays.fill(sz, 1);
}
public int find(int a) {
if(arr[a]!=a) arr[a] = find(arr[a]);
return arr[a];
}
public void union(int a, int b) {
int x = find(a);
int y = find(b);
if(x==y) return;
arr[x] = y;
sz[y] += sz[x];
}
public int size(int x) {
return sz[find(x)];
}
}
static class MinHeap<Key> implements Iterable<Key> {
private int maxN;
private int n;
private int[] pq;
private int[] qp;
private Key[] keys;
private Comparator<Key> comparator;
public MinHeap(int capacity){
if (capacity < 0) throw new IllegalArgumentException();
this.maxN = capacity;
n=0;
pq = new int[maxN+1];
qp = new int[maxN+1];
keys = (Key[]) new Object[capacity+1];
Arrays.fill(qp, -1);
}
public MinHeap(int capacity, Comparator<Key> c){
if (capacity < 0) throw new IllegalArgumentException();
this.maxN = capacity;
n=0;
pq = new int[maxN+1];
qp = new int[maxN+1];
keys = (Key[]) new Object[capacity+1];
Arrays.fill(qp, -1);
comparator = c;
}
public boolean isEmpty() { return n==0; }
public int size() { return n; }
public boolean contains(int i) {
if (i < 0 || i >= maxN) throw new IllegalArgumentException();
return qp[i] != -1;
}
public int peekIdx() {
if (n == 0) throw new NoSuchElementException("Priority queue underflow");
return pq[1];
}
public Key peek(){
if(isEmpty()) throw new NoSuchElementException("Priority queue underflow");
return keys[pq[1]];
}
public int poll(){
if(isEmpty()) throw new NoSuchElementException("Priority queue underflow");
int min = pq[1];
exch(1,n--);
down(1);
assert min==pq[n+1];
qp[min] = -1;
keys[min] = null;
pq[n+1] = -1;
return min;
}
public void update(int i, Key key) {
if (i < 0 || i >= maxN) throw new IllegalArgumentException();
if (!contains(i)) {
this.add(i, key);
}else {
keys[i] = key;
up(qp[i]);
down(qp[i]);
}
}
private void add(int i, Key x){
if (i < 0 || i >= maxN) throw new IllegalArgumentException();
if (contains(i)) throw new IllegalArgumentException("index is already in the priority queue");
n++;
qp[i] = n;
pq[n] = i;
keys[i] = x;
up(n);
}
private void up(int k){
while(k>1&&less(k,k/2)){
exch(k,k/2);
k/=2;
}
}
private void down(int k){
while(2*k<=n){
int j=2*k;
if(j<n&&less(j+1,j)) j++;
if(less(k,j)) break;
exch(k,j);
k=j;
}
}
public boolean less(int i, int j){
if (comparator == null) {
return ((Comparable<Key>) keys[pq[i]]).compareTo(keys[pq[j]]) < 0;
}
else {
return comparator.compare(keys[pq[i]], keys[pq[j]]) < 0;
}
}
public void exch(int i, int j){
int swap = pq[i];
pq[i] = pq[j];
pq[j] = swap;
qp[pq[i]] = i;
qp[pq[j]] = j;
}
@Override
public Iterator<Key> iterator() {
// TODO Auto-generated method stub
return null;
}
}
private static class InputReader
{
private InputStream stream;
private byte[] buf = new byte[1024];
private int zcurChar;
private int znumChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream)
{
this.stream = stream;
}
public int read()
{
if (znumChars == -1)
throw new InputMismatchException();
if (zcurChar >= znumChars)
{
zcurChar = 0;
try
{
znumChars = stream.read(buf);
} catch (IOException e)
{
throw new InputMismatchException();
}
if (znumChars <= 0)
return -1;
}
return buf[zcurChar++];
}
public int nextInt()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
int res = 0;
do
{
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String nextString()
{
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do
{
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public double nextDouble()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.')
{
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
if (c == '.')
{
c = read();
double m = 1;
while (!isSpaceChar(c))
{
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public long nextLong()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
long res = 0;
do
{
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c)
{
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next()
{
return nextString();
}
public interface SpaceCharFilter
{
public boolean isSpaceChar(int ch);
}
public int[] readIntArray(int n) {
int[] ret = new int[n];
for (int i = 0; i < n; i++) {
ret[i] = nextInt();
}
return ret;
}
}
static class Dumper {
static void print_int_arr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_char_arr(char[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_double_arr(double[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_2d_arr(int[][] arr, int x, int y) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("---------------------");
}
static void print_2d_arr(boolean[][] arr, int x, int y) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("---------------------");
}
static void print(Object o) {
System.out.println(o.toString());
}
static void getc() {
System.out.println("here");
}
}
}
|
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3fll;
long long cnt[200005];
long long cost[200005];
set<pair<long long, long long>> primeset;
void SieveOfEratosthenes(long long n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (long long p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (long long p = 2; p <= n; p++)
if (prime[p]) primeset.insert(make_pair(p, 1));
}
void countDivisors(long long n) {
long long cnt = 0;
for (long long i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
cnt++;
else
cnt = cnt + 2;
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
countDivisors(20);
countDivisors(20);
long long n, k;
cin >> n >> k;
countDivisors(20);
countDivisors(20);
countDivisors(20);
countDivisors(20);
long long arr[n];
for (long long(i) = 0; i < n; i++) {
cin >> arr[i];
}
countDivisors(20);
countDivisors(20);
sort(arr, arr + n);
countDivisors(20);
countDivisors(20);
countDivisors(20);
for (long long(i) = 0; i < n; i++) {
long long a = arr[i];
countDivisors(20);
countDivisors(20);
countDivisors(20);
long long temp = 0;
countDivisors(20);
countDivisors(20);
while (a) {
countDivisors(20);
countDivisors(20);
if (cnt[a] < k) {
countDivisors(20);
countDivisors(20);
cost[a] += temp;
countDivisors(20);
countDivisors(20);
cnt[a]++;
}
countDivisors(20);
countDivisors(20);
temp++;
a /= 2;
countDivisors(20);
countDivisors(20);
countDivisors(20);
countDivisors(20);
}
}
long long ans = inf;
for (long long(i) = 0; i < 200005; i++) {
SieveOfEratosthenes(7);
countDivisors(20);
if (cnt[i] >= k) ans = min(cost[i], ans);
}
SieveOfEratosthenes(7);
countDivisors(20);
cout << ans;
return 0;
}
|
Alice is playing a game with her good friend, Marisa.
There are n boxes arranged in a line, numbered with integers from 1 to n from left to right. Marisa will hide a doll in one of the boxes. Then Alice will have m chances to guess where the doll is. If Alice will correctly guess the number of box, where doll is now, she will win the game, otherwise, her friend will win the game.
In order to win, Marisa will use some unfair tricks. After each time Alice guesses a box, she can move the doll to the neighboring box or just keep it at its place. Boxes i and i + 1 are neighboring for all 1 ≤ i ≤ n - 1. She can also use this trick once before the game starts.
So, the game happens in this order: the game starts, Marisa makes the trick, Alice makes the first guess, Marisa makes the trick, Alice makes the second guess, Marisa makes the trick, …, Alice makes m-th guess, Marisa makes the trick, the game ends.
Alice has come up with a sequence a_1, a_2, …, a_m. In the i-th guess, she will ask if the doll is in the box a_i. She wants to know the number of scenarios (x, y) (for all 1 ≤ x, y ≤ n), such that Marisa can win the game if she will put the doll at the x-th box at the beginning and at the end of the game, the doll will be at the y-th box. Help her and calculate this number.
Input
The first line contains two integers n and m, separated by space (1 ≤ n, m ≤ 10^5) — the number of boxes and the number of guesses, which Alice will make.
The next line contains m integers a_1, a_2, …, a_m, separated by spaces (1 ≤ a_i ≤ n), the number a_i means the number of the box which Alice will guess in the i-th guess.
Output
Print the number of scenarios in a single line, or the number of pairs of boxes (x, y) (1 ≤ x, y ≤ n), such that if Marisa will put the doll into the box with number x, she can make tricks in such way, that at the end of the game the doll will be in the box with number y and she will win the game.
Examples
Input
3 3
2 2 2
Output
7
Input
5 2
3 1
Output
21
Note
In the first example, the possible scenarios are (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3).
Let's take (2, 2) as an example. The boxes, in which the doll will be during the game can be 2 → 3 → 3 → 3 → 2
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5;
int n, m, a[maxn], l[maxn], r[maxn];
long long ans = 0;
int main() {
scanf("%d%d", &n, &m);
if (n == 1) {
printf("0\n");
return 0;
}
memset(l, 0, sizeof(l));
memset(r, 0, sizeof(r));
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
}
for (int i = m; i >= 1; i--) {
l[a[i] + i + m] = l[a[i] + i + m + 1] + 1;
r[a[i] - i + m] = r[a[i] - i + m - 1] + 1;
}
for (int i = 1; i <= n; i++) {
int ll = max(i - m - 1 + l[i + m], 1), rr = min(i + m + 1 - r[i + m], n);
ans += (rr - ll + 1);
}
printf("%lld\n", ans);
return 0;
}
|
This is an interactive problem.
Khanh has n points on the Cartesian plane, denoted by a_1, a_2, …, a_n. All points' coordinates are integers between -10^9 and 10^9, inclusive. No three points are collinear. He says that these points are vertices of a convex polygon; in other words, there exists a permutation p_1, p_2, …, p_n of integers from 1 to n such that the polygon a_{p_1} a_{p_2} … a_{p_n} is convex and vertices are listed in counter-clockwise order.
Khanh gives you the number n, but hides the coordinates of his points. Your task is to guess the above permutation by asking multiple queries. In each query, you give Khanh 4 integers t, i, j, k; where either t = 1 or t = 2; and i, j, k are three distinct indices from 1 to n, inclusive. In response, Khanh tells you:
* if t = 1, the area of the triangle a_ia_ja_k multiplied by 2.
* if t = 2, the sign of the cross product of two vectors \overrightarrow{a_ia_j} and \overrightarrow{a_ia_k}.
Recall that the cross product of vector \overrightarrow{a} = (x_a, y_a) and vector \overrightarrow{b} = (x_b, y_b) is the integer x_a ⋅ y_b - x_b ⋅ y_a. The sign of a number is 1 it it is positive, and -1 otherwise. It can be proven that the cross product obtained in the above queries can not be 0.
You can ask at most 3 ⋅ n queries.
Please note that Khanh fixes the coordinates of his points and does not change it while answering your queries. You do not need to guess the coordinates. In your permutation a_{p_1}a_{p_2}… a_{p_n}, p_1 should be equal to 1 and the indices of vertices should be listed in counter-clockwise order.
Interaction
You start the interaction by reading n (3 ≤ n ≤ 1 000) — the number of vertices.
To ask a query, write 4 integers t, i, j, k (1 ≤ t ≤ 2, 1 ≤ i, j, k ≤ n) in a separate line. i, j and k should be distinct.
Then read a single integer to get the answer to this query, as explained above. It can be proven that the answer of a query is always an integer.
When you find the permutation, write a number 0. Then write n integers p_1, p_2, …, p_n in the same line.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hack format
To hack, use the following format:
The first line contains an integer n (3 ≤ n ≤ 1 000) — the number of vertices.
The i-th of the next n lines contains two integers x_i and y_i (-10^9 ≤ x_i, y_i ≤ 10^9) — the coordinate of the point a_i.
Example
Input
6
15
-1
1
Output
1 1 4 6
2 1 5 6
2 2 1 4
0 1 3 4 2 6 5
Note
The image below shows the hidden polygon in the example:
<image>
The interaction in the example goes as below:
* Contestant reads n = 6.
* Contestant asks a query with t = 1, i = 1, j = 4, k = 6.
* Jury answers 15. The area of the triangle A_1A_4A_6 is 7.5. Note that the answer is two times the area of the triangle.
* Contestant asks a query with t = 2, i = 1, j = 5, k = 6.
* Jury answers -1. The cross product of \overrightarrow{A_1A_5} = (2, 2) and \overrightarrow{A_1A_6} = (4, 1) is -2. The sign of -2 is -1.
* Contestant asks a query with t = 2, i = 2, j = 1, k = 4.
* Jury answers 1. The cross product of \overrightarrow{A_2A_1} = (-5, 2) and \overrightarrow{A_2A_4} = (-2, -1) is 1. The sign of 1 is 1.
* Contestant says that the permutation is (1, 3, 4, 2, 6, 5).
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
using namespace std;
int a, b, c, d, n, m, k;
long long sq[1002];
bool uu[1002];
inline void sr(vector<int>& a) {
sort(a.begin(), a.end(),
[](const int& a, const int& b) { return sq[a] < sq[b]; });
}
int main() {
srand(29756111 + time(0));
scanf("%d", &n);
int lf = 0, rt = rand() % n;
while (!rt) rt = rand() % n;
vector<int> up, down;
for (int _n((n)-1), i(0); i <= _n; i++) {
if (i == lf || i == rt) continue;
printf("%d %d %d %d\n", 2, lf + 1, rt + 1, i + 1);
fflush(stdout);
scanf("%d", &a);
if (a == 1) {
up.push_back(i);
uu[i] = 1;
} else {
down.push_back(i);
}
printf("%d %d %d %d\n", 1, lf + 1, rt + 1, i + 1);
fflush(stdout);
scanf("%I64d", &sq[i]);
}
int uv = -1, dv = -1;
for (int _n(((int)((up).size())) - 1), i(0); i <= _n; i++) {
int v = up[i];
if (uv == -1 || sq[v] > sq[uv]) {
uv = v;
}
}
for (int _n(((int)((down).size())) - 1), i(0); i <= _n; i++) {
int v = down[i];
if (dv == -1 || sq[v] > sq[dv]) {
dv = v;
}
}
vector<int> lu, ru, ld, rd;
for (int _n((n)-1), i(0); i <= _n; i++) {
if (i == lf || i == rt || i == uv || i == dv) continue;
if (uu[i]) {
printf("%d %d %d %d\n", 2, lf + 1, uv + 1, i + 1);
fflush(stdout);
scanf("%d", &a);
if (a == 1) {
lu.push_back(i);
} else {
ru.push_back(i);
}
} else {
printf("%d %d %d %d\n", 2, lf + 1, dv + 1, i + 1);
fflush(stdout);
scanf("%d", &a);
if (a == 1) {
rd.push_back(i);
} else {
ld.push_back(i);
}
}
}
sr(lu);
sr(ru);
sr(ld);
sr(rd);
vector<int> res;
res.push_back(lf);
for (int _n(((int)((ld).size())) - 1), i(0); i <= _n; i++)
res.push_back(ld[i]);
if (dv != -1) res.push_back(dv);
for (int i = ((int)((rd).size()) - 1), _b = (0); i >= _b; i--)
res.push_back(rd[i]);
res.push_back(rt);
for (int _n(((int)((ru).size())) - 1), i(0); i <= _n; i++)
res.push_back(ru[i]);
if (uv != -1) res.push_back(uv);
for (int i = ((int)((lu).size()) - 1), _b = (0); i >= _b; i--)
res.push_back(lu[i]);
printf("0");
for (int _n(((int)((res).size())) - 1), i(0); i <= _n; i++)
printf(" %d", res[i] + 1);
printf("\n");
fflush(stdout);
}
|
Karlsson has recently discovered a huge stock of berry jam jars in the basement of the house. More specifically, there were 2n jars of strawberry and blueberry jam.
All the 2n jars are arranged in a row. The stairs to the basement are exactly in the middle of that row. So when Karlsson enters the basement, he sees exactly n jars to his left and n jars to his right.
For example, the basement might look like this:
<image>
Being the starightforward man he is, he immediately starts eating the jam. In one minute he chooses to empty either the first non-empty jar to his left or the first non-empty jar to his right.
Finally, Karlsson decided that at the end the amount of full strawberry and blueberry jam jars should become the same.
For example, this might be the result:
<image> He has eaten 1 jar to his left and then 5 jars to his right. There remained exactly 3 full jars of both strawberry and blueberry jam.
Jars are numbered from 1 to 2n from left to right, so Karlsson initially stands between jars n and n+1.
What is the minimum number of jars Karlsson is required to empty so that an equal number of full strawberry and blueberry jam jars is left?
Your program should answer t independent test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ 2) — a_i=1 means that the i-th jar from the left is a strawberry jam jar and a_i=2 means that it is a blueberry jam jar.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case print the answer to it — the minimum number of jars Karlsson is required to empty so that an equal number of full strawberry and blueberry jam jars is left.
Example
Input
4
6
1 1 1 2 2 1 2 1 2 1 1 2
2
1 2 1 2
3
1 1 1 1 1 1
2
2 1 1 1
Output
6
0
6
2
Note
The picture from the statement describes the first test case.
In the second test case the number of strawberry and blueberry jam jars is already equal.
In the third test case Karlsson is required to eat all 6 jars so that there remain 0 jars of both jams.
In the fourth test case Karlsson can empty either the second and the third jars or the third and the fourth one. The both scenarios will leave 1 jar of both jams.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
int a[maxn * 2];
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
int red = 0, blue = 0;
map<int, int> m;
for (int i = 1; i <= n * 2; i++) {
int color;
scanf("%d", &color);
if (color == 1) {
red++;
a[i] = 1;
} else {
blue++;
a[i] = -1;
}
}
if (red == blue) {
puts("0");
continue;
}
m[0] = n;
m[a[n + 1]] = n + 1;
for (int i = n + 2; i <= n * 2; i++) {
a[i] += a[i - 1];
if (!m.count(a[i])) {
m[a[i]] = i;
}
}
int lsum = 0;
int diff = red - blue;
int ans = n * 2;
if (m.count(diff)) {
ans = min(ans, m[diff] - n);
}
for (int i = n; i; i--) {
lsum += a[i];
if (m.count(diff - lsum)) {
int r = m[diff - lsum];
ans = min(ans, r - i + 1);
}
}
printf("%d\n", ans);
}
return 0;
}
|
The map of Bertown can be represented as a set of n intersections, numbered from 1 to n and connected by m one-way roads. It is possible to move along the roads from any intersection to any other intersection. The length of some path from one intersection to another is the number of roads that one has to traverse along the path. The shortest path from one intersection v to another intersection u is the path that starts in v, ends in u and has the minimum length among all such paths.
Polycarp lives near the intersection s and works in a building near the intersection t. Every day he gets from s to t by car. Today he has chosen the following path to his workplace: p_1, p_2, ..., p_k, where p_1 = s, p_k = t, and all other elements of this sequence are the intermediate intersections, listed in the order Polycarp arrived at them. Polycarp never arrived at the same intersection twice, so all elements of this sequence are pairwise distinct. Note that you know Polycarp's path beforehand (it is fixed), and it is not necessarily one of the shortest paths from s to t.
Polycarp's car has a complex navigation system installed in it. Let's describe how it works. When Polycarp starts his journey at the intersection s, the system chooses some shortest path from s to t and shows it to Polycarp. Let's denote the next intersection in the chosen path as v. If Polycarp chooses to drive along the road from s to v, then the navigator shows him the same shortest path (obviously, starting from v as soon as he arrives at this intersection). However, if Polycarp chooses to drive to another intersection w instead, the navigator rebuilds the path: as soon as Polycarp arrives at w, the navigation system chooses some shortest path from w to t and shows it to Polycarp. The same process continues until Polycarp arrives at t: if Polycarp moves along the road recommended by the system, it maintains the shortest path it has already built; but if Polycarp chooses some other path, the system rebuilds the path by the same rules.
Here is an example. Suppose the map of Bertown looks as follows, and Polycarp drives along the path [1, 2, 3, 4] (s = 1, t = 4):
Check the picture by the link [http://tk.codeforces.com/a.png](//tk.codeforces.com/a.png)
1. When Polycarp starts at 1, the system chooses some shortest path from 1 to 4. There is only one such path, it is [1, 5, 4];
2. Polycarp chooses to drive to 2, which is not along the path chosen by the system. When Polycarp arrives at 2, the navigator rebuilds the path by choosing some shortest path from 2 to 4, for example, [2, 6, 4] (note that it could choose [2, 3, 4]);
3. Polycarp chooses to drive to 3, which is not along the path chosen by the system. When Polycarp arrives at 3, the navigator rebuilds the path by choosing the only shortest path from 3 to 4, which is [3, 4];
4. Polycarp arrives at 4 along the road chosen by the navigator, so the system does not have to rebuild anything.
Overall, we get 2 rebuilds in this scenario. Note that if the system chose [2, 3, 4] instead of [2, 6, 4] during the second step, there would be only 1 rebuild (since Polycarp goes along the path, so the system maintains the path [3, 4] during the third step).
The example shows us that the number of rebuilds can differ even if the map of Bertown and the path chosen by Polycarp stays the same. Given this information (the map and Polycarp's path), can you determine the minimum and the maximum number of rebuilds that could have happened during the journey?
Input
The first line contains two integers n and m (2 ≤ n ≤ m ≤ 2 ⋅ 10^5) — the number of intersections and one-way roads in Bertown, respectively.
Then m lines follow, each describing a road. Each line contains two integers u and v (1 ≤ u, v ≤ n, u ≠ v) denoting a road from intersection u to intersection v. All roads in Bertown are pairwise distinct, which means that each ordered pair (u, v) appears at most once in these m lines (but if there is a road (u, v), the road (v, u) can also appear).
The following line contains one integer k (2 ≤ k ≤ n) — the number of intersections in Polycarp's path from home to his workplace.
The last line contains k integers p_1, p_2, ..., p_k (1 ≤ p_i ≤ n, all these integers are pairwise distinct) — the intersections along Polycarp's path in the order he arrived at them. p_1 is the intersection where Polycarp lives (s = p_1), and p_k is the intersection where Polycarp's workplace is situated (t = p_k). It is guaranteed that for every i ∈ [1, k - 1] the road from p_i to p_{i + 1} exists, so the path goes along the roads of Bertown.
Output
Print two integers: the minimum and the maximum number of rebuilds that could have happened during the journey.
Examples
Input
6 9
1 5
5 4
1 2
2 3
3 4
4 1
2 6
6 4
4 2
4
1 2 3 4
Output
1 2
Input
7 7
1 2
2 3
3 4
4 5
5 6
6 7
7 1
7
1 2 3 4 5 6 7
Output
0 0
Input
8 13
8 7
8 6
7 5
7 4
6 5
6 4
5 3
5 2
4 3
4 2
3 1
2 1
1 8
5
8 7 5 2 1
Output
0 3
|
import java.io.*;
import java.lang.Math;
import java.util.*;
public class Main {
public BufferedReader in;
public PrintStream out;
public boolean log_enabled = false;
public boolean multiply_tests = false;
public static boolean do_gen_test = false;
public void gen_test() {
}
private class TestCase {
private class Graph
{
int N;
int[][] adj_list;
int[] adj_count;
int[] P;
boolean[] M;
int[] color;
Graph(int n)
{
N = n;
adj_count = new int[N];
adj_list = new int[N][];
P = new int[N];
color = new int[N];
M = new boolean[N];
Arrays.fill(color, 0);
Arrays.fill(M, false);
}
void read_adj_list(int m)
{
int[] uv = new int[2*m+1];
Arrays.fill(adj_count, 0);
int i;
for (i=0; i<m; i++)
{
uv[2*i ] = readInt()-1;
uv[2*i+1] = readInt()-1;
adj_count[uv[2*i+1]] ++;
}
for (i=0; i<N; i++)
{
adj_list[i] = new int[ adj_count[i] ];
}
Arrays.fill(adj_count, 0);
for (i=0; i<m; i++)
{
adj_list[uv[2*i+1]][ adj_count[uv[2*i+1]]++ ] = uv[2*i];
}
}
public void bfs(int t)
{
int[] Q = new int[2*N];
int qh = 0, qt = 1;
Q[0] = t;
color[t] = 1;
P[t] = 0;
int i, u, v;
while (qh<qt)
{
u = Q[qh++];
for (i=0; i<adj_count[u]; i++)
{
v = adj_list[u][i];
if (color[v]==0)
{
color[v] = 1;
P[v] = P[u]+1;
Q[qt++] = v;
}
else if ((color[v]==1) && (P[v] == 1+P[u]) )
{
M[v] = true;
}
}
color[u] = 2;
}
}
}
public Object solve() {
int n = readInt(), m = readInt();
Graph G= new Graph(n);
G.read_adj_list(m);
int i, k = readInt();
int[] p = new int[k];
for (i=0; i<k; i++)
{
p[i] = readInt()-1;
}
G.bfs(p[k-1]);
int min = 0, max = 0;
for (i=0; i<k-1; i++)
{
if (G.M[p[i]] || (G.P[p[i]]-1 < G.P[p[i+1]] ))
{
max ++;
}
if (G.P[p[i]]-1 < G.P[p[i+1]] )
{
min ++;
}
}
return strf("%d %d", min, max);
//out.printf("Case #%d: \n", caseNumber);
//return null;
}
public int caseNumber;
TestCase(int number) {
caseNumber = number;
}
public void run(){
Object r = this.solve();
if ((r != null))
{
//outputCaseNumber(r);
out.println(r);
}
}
public String impossible(){
return "IMPOSSIBLE";
}
public String strf(String format, Object... args)
{
return String.format(format, args);
}
// public void outputCaseNumber(Object r){
// //out.printf("Case #%d:", caseNumber);
// if (r != null)
// {
// // out.print(" ");
// out.print(r);
// }
// out.print("\n");
// }
}
public void run() {
//while (true)
{
int t = multiply_tests ? readInt() : 1;
for (int i = 0; i < t; i++) {
TestCase T = new TestCase(i + 1);
T.run();
}
}
}
public Main(BufferedReader _in, PrintStream _out){
in = _in;
out = _out;
}
public static void main(String args[]) {
Locale.setDefault(Locale.US);
Main S;
try {
S = new Main(
new BufferedReader(new InputStreamReader(System.in)),
System.out
);
} catch (Exception e) {
return;
}
S.run();
}
private StringTokenizer tokenizer = null;
public int readInt() {
return Integer.parseInt(readToken());
}
public long readLong() {
return Long.parseLong(readToken());
}
public double readDouble() {
return Double.parseDouble(readToken());
}
public String readLn() {
try {
String s;
while ((s = in.readLine()).length() == 0);
return s;
} catch (Exception e) {
return "";
}
}
public String readToken() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(in.readLine());
}
return tokenizer.nextToken();
} catch (Exception e) {
return "";
}
}
public int[] readIntArray(int n) {
int[] x = new int[n];
readIntArray(x, n);
return x;
}
public int[] readIntArrayBuf(int n) {
int[] x = new int[n];
readIntArrayBuf(x, n);
return x;
}
public void readIntArray(int[] x, int n) {
for (int i = 0; i < n; i++) {
x[i] = readInt();
}
}
public long[] readLongArray(int n) {
long[] x = new long[n];
readLongArray(x, n);
return x;
}
public long[] readLongArrayBuf(int n) {
long[] x = new long[n];
readLongArrayBuf(x, n);
return x;
}
public void readLongArray(long[] x, int n) {
for (int i = 0; i < n; i++) {
x[i] = readLong();
}
}
public void logWrite(String format, Object... args) {
if (!log_enabled) {
return;
}
out.printf(format, args);
}
public void readLongArrayBuf(long[] x, int n) {
char[]buf = new char[1000000];
long r = -1;
int k= 0, l = 0;
long d;
while (true)
{
try{
l = in.read(buf, 0, 1000000);
}
catch(Exception E){};
for (int i=0; i<l; i++)
{
if (('0'<=buf[i])&&(buf[i]<='9'))
{
if (r == -1)
{
r = 0;
}
d = buf[i] - '0';
r = 10 * r + d;
}
else
{
if (r != -1)
{
x[k++] = r;
}
r = -1;
}
}
if (l<1000000)
return;
}
}
public void readIntArrayBuf(int[] x, int n) {
char[]buf = new char[1000000];
int r = -1;
int k= 0, l = 0;
int d;
while (true)
{
try{
l = in.read(buf, 0, 1000000);
}
catch(Exception E){};
for (int i=0; i<l; i++)
{
if (('0'<=buf[i])&&(buf[i]<='9'))
{
if (r == -1)
{
r = 0;
}
d = buf[i] - '0';
r = 10 * r + d;
}
else
{
if (r != -1)
{
x[k++] = r;
}
r = -1;
}
}
if (l<1000000)
return;
}
}
public void printArray(long[] a, int n)
{
printArray(a, n, ' ');
}
public void printArray(int[] a, int n)
{
printArray(a, n, ' ');
}
public void printArray(long[] a, int n, char dl)
{
long x;
int i, l = 0;
for (i=0; i<n; i++)
{
x = a[i];
if (x<0)
{
x = -x;
l++;
}
if (x==0)
{
l++;
}
else
{
while (x>0)
{
x /= 10;
l++;
}
}
}
l += n-1;
char[] s = new char[l];
l--;
boolean z;
for (i=n-1; i>=0; i--)
{
x = a[i];
z = false;
if (x<0)
{
x = -x;
z = true;
}
do{
s[l--] = (char)('0' + (x % 10));
x /= 10;
} while (x>0);
if (z)
{
s[l--] = '-';
}
if (i>0)
{
s[l--] = dl;
}
}
out.println(new String(s));
}
public void printArray(int[] a, int n, char dl)
{
int x;
int i, l = 0;
for (i=0; i<n; i++)
{
x = a[i];
if (x<0)
{
x = -x;
l++;
}
if (x==0)
{
l++;
}
else
{
while (x>0)
{
x /= 10;
l++;
}
}
}
l += n-1;
char[] s = new char[l];
l--;
boolean z;
for (i=n-1; i>=0; i--)
{
x = a[i];
z = false;
if (x<0)
{
x = -x;
z = true;
}
do{
s[l--] = (char)('0' + (x % 10));
x /= 10;
} while (x>0);
if (z)
{
s[l--] = '-';
}
if (i>0)
{
s[l--] = dl;
}
}
out.println(new String(s));
}
public void printMatrix(int[][] a, int n, int m)
{
int x;
int i,j, l = 0;
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
{
x = a[i][j];
if (x<0)
{
x = -x;
l++;
}
if (x==0)
{
l++;
}
else
{
while (x>0)
{
x /= 10;
l++;
}
}
}
l += m-1;
}
l += n-1;
char[] s = new char[l];
l--;
boolean z;
for (i=n-1; i>=0; i--)
{
for (j=m-1; j>=0; j--)
{
x = a[i][j];
z = false;
if (x<0)
{
x = -x;
z = true;
}
do{
s[l--] = (char)('0' + (x % 10));
x /= 10;
} while (x>0);
if (z)
{
s[l--] = '-';
}
if (j>0)
{
s[l--] = ' ';
}
}
if (i>0)
{
s[l--] = '\n';
}
}
out.println(new String(s));
}
public void printMatrix(long[][] a, int n, int m)
{
long x;
int i,j, l = 0;
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
{
x = a[i][j];
if (x<0)
{
x = -x;
l++;
}
if (x==0)
{
l++;
}
else
{
while (x>0)
{
x /= 10;
l++;
}
}
}
l += m-1;
}
l += n-1;
char[] s = new char[l];
l--;
boolean z;
for (i=n-1; i>=0; i--)
{
for (j=m-1; j>=0; j--)
{
x = a[i][j];
z = false;
if (x<0)
{
x = -x;
z = true;
}
do{
s[l--] = (char)('0' + (x % 10));
x /= 10;
} while (x>0);
if (z)
{
s[l--] = '-';
}
if (j>0)
{
s[l--] = ' ';
}
}
if (i>0)
{
s[l--] = '\n';
}
}
out.println(new String(s));
}
}
|
If the girl doesn't go to Denis, then Denis will go to the girl. Using this rule, the young man left home, bought flowers and went to Nastya.
On the way from Denis's house to the girl's house is a road of n lines. This road can't be always crossed in one green light. Foreseeing this, the good mayor decided to place safety islands in some parts of the road. Each safety island is located after a line, as well as at the beginning and at the end of the road. Pedestrians can relax on them, gain strength and wait for a green light.
Denis came to the edge of the road exactly at the moment when the green light turned on. The boy knows that the traffic light first lights up g seconds green, and then r seconds red, then again g seconds green and so on.
Formally, the road can be represented as a segment [0, n]. Initially, Denis is at point 0. His task is to get to point n in the shortest possible time.
He knows many different integers d_1, d_2, …, d_m, where 0 ≤ d_i ≤ n — are the coordinates of points, in which the safety islands are located. Only at one of these points, the boy can be at a time when the red light is on.
Unfortunately, Denis isn't always able to control himself because of the excitement, so some restrictions are imposed:
* He must always move while the green light is on because it's difficult to stand when so beautiful girl is waiting for you. Denis can change his position by ± 1 in 1 second. While doing so, he must always stay inside the segment [0, n].
* He can change his direction only on the safety islands (because it is safe). This means that if in the previous second the boy changed his position by +1 and he walked on a safety island, then he can change his position by ± 1. Otherwise, he can change his position only by +1. Similarly, if in the previous second he changed his position by -1, on a safety island he can change position by ± 1, and at any other point by -1.
* At the moment when the red light is on, the boy must be on one of the safety islands. He can continue moving in any direction when the green light is on.
Denis has crossed the road as soon as his coordinate becomes equal to n.
This task was not so simple, because it's possible that it is impossible to cross the road. Since Denis has all thoughts about his love, he couldn't solve this problem and asked us to help him. Find the minimal possible time for which he can cross the road according to these rules, or find that it is impossible to do.
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^6, 2 ≤ m ≤ min(n + 1, 10^4)) — road width and the number of safety islands.
The second line contains m distinct integers d_1, d_2, …, d_m (0 ≤ d_i ≤ n) — the points where the safety islands are located. It is guaranteed that there are 0 and n among them.
The third line contains two integers g, r (1 ≤ g, r ≤ 1000) — the time that the green light stays on and the time that the red light stays on.
Output
Output a single integer — the minimum time for which Denis can cross the road with obeying all the rules.
If it is impossible to cross the road output -1.
Examples
Input
15 5
0 3 7 14 15
11 11
Output
45
Input
13 4
0 3 7 13
9 9
Output
-1
Note
In the first test, the optimal route is:
* for the first green light, go to 7 and return to 3. In this case, we will change the direction of movement at the point 7, which is allowed, since there is a safety island at this point. In the end, we will be at the point of 3, where there is also a safety island. The next 11 seconds we have to wait for the red light.
* for the second green light reaches 14. Wait for the red light again.
* for 1 second go to 15. As a result, Denis is at the end of the road.
In total, 45 seconds are obtained.
In the second test, it is impossible to cross the road according to all the rules.
|
import java.io.*;
import java.util.*;
public class Main{
static int pairToNum(int i,int j) {
return i*m+j;
}
static int[] numToPair(int num) {
return new int[] {num/m,num%m};
}
static long INF=(long)1e15;
static int n,m;
public static void main(String[] args) throws Exception{
PrintWriter pw=new PrintWriter(System.out);
MScanner sc = new MScanner(System.in);
n=sc.nextInt();m=sc.nextInt();
int[]in=sc.intSortedArr(m);
int g=sc.nextInt(),r=sc.nextInt();
long[][]dist=new long[g+1][m];
for(int i=0;i<dist.length;i++)Arrays.fill(dist[i],INF);
LinkedList<int[]>q=new LinkedList<int[]>();
q.add(new int[] {0,0});
dist[0][0]=0;
while(!q.isEmpty()) {
int []pair=q.pollFirst();
int time=pair[0],pos=pair[1];
if(time==g) {
//we are in red light
//go to green
int goT=0,goP=pos;
if(dist[time][pos]+1<dist[goT][goP]) {
dist[goT][goP]=dist[time][pos]+1;
q.addLast(new int[] {goT,goP});
}
continue;
}
//we are in green
int curPos=in[pos];
if(pos<m-1) {//move positive
int nxt=in[pos+1];
int d=Math.abs(curPos-nxt);
if(time+d<=g) {
int goT=time+d,goP=pos+1;
if(dist[time][pos]<dist[goT][goP]) {
dist[goT][goP]=dist[time][pos];
q.addFirst(new int[] {goT,goP});
}
}
}
if(pos>0) {//move negative
int nxt=in[pos-1];
int d=Math.abs(curPos-nxt);
if(time+d<=g) {
int goT=time+d,goP=pos-1;
if(dist[time][pos]<dist[goT][goP]) {
dist[goT][goP]=dist[time][pos];
q.addFirst(new int[] {goT,goP});
}
}
}
}
long ans=INF;
for(int t=0;t<=g;t++) {
int time=t,pos=m-1;
ans=Math.min(ans, dist[time][pos]*(r+g)+t);
// System.out.println(dist[pairToNum(time, pos)]+" "+time+" "+pos);
}
if(ans>=INF) {
pw.println(-1);
}
else
pw.println(ans);
pw.flush();
}
static class MScanner {
StringTokenizer st;
BufferedReader br;
public MScanner(InputStream system) {
br = new BufferedReader(new InputStreamReader(system));
}
public MScanner(String file) throws Exception {
br = new BufferedReader(new FileReader(file));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int[] intArr(int n) throws IOException {
int[]in=new int[n];for(int i=0;i<n;i++)in[i]=nextInt();
return in;
}
public long[] longArr(int n) throws IOException {
long[]in=new long[n];for(int i=0;i<n;i++)in[i]=nextLong();
return in;
}
public int[] intSortedArr(int n) throws IOException {
int[]in=new int[n];for(int i=0;i<n;i++)in[i]=nextInt();
shuffle(in);
Arrays.sort(in);
return in;
}
public long[] longSortedArr(int n) throws IOException {
long[]in=new long[n];for(int i=0;i<n;i++)in[i]=nextLong();
shuffle(in);
Arrays.sort(in);
return in;
}
public Integer[] IntegerArr(int n) throws IOException {
Integer[]in=new Integer[n];for(int i=0;i<n;i++)in[i]=nextInt();
return in;
}
public Long[] LongArr(int n) throws IOException {
Long[]in=new Long[n];for(int i=0;i<n;i++)in[i]=nextLong();
return in;
}
public String nextLine() throws IOException {
return br.readLine();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public char nextChar() throws IOException {
return next().charAt(0);
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public boolean ready() throws IOException {
return br.ready();
}
public void waitForInput() throws InterruptedException {
Thread.sleep(3000);
}
}
static void shuffle(int[]in) {
for(int i=0;i<in.length;i++) {
int idx = i + (int)(Math.random() * (in.length - i));
int tmp=in[i];
in[i]=in[idx];
in[idx]=tmp;
}
}
static void shuffle(long[]in) {
for(int i=0;i<in.length;i++) {
int idx = i + (int)(Math.random() * (in.length - i));
long tmp=in[i];
in[i]=in[idx];
in[idx]=tmp;
}
}
static String arrToString(int[]x) {
return Arrays.toString(x);
}
static String arrToString(long[]x) {
return Arrays.toString(x);
}
static String arrToString(Integer[]x) {
return Arrays.toString(x);
}
static String arrToString(Long[]x) {
return Arrays.toString(x);
}
}
|
The last contest held on Johnny's favorite competitive programming platform has been received rather positively. However, Johnny's rating has dropped again! He thinks that the presented tasks are lovely, but don't show the truth about competitors' skills.
The boy is now looking at the ratings of consecutive participants written in a binary system. He thinks that the more such ratings differ, the more unfair is that such people are next to each other. He defines the difference between two numbers as the number of bit positions, where one number has zero, and another has one (we suppose that numbers are padded with leading zeros to the same length). For example, the difference of 5 = 101_2 and 14 = 1110_2 equals to 3, since 0101 and 1110 differ in 3 positions. Johnny defines the unfairness of the contest as the sum of such differences counted for neighboring participants.
Johnny has just sent you the rating sequence and wants you to find the unfairness of the competition. You have noticed that you've got a sequence of consecutive integers from 0 to n. That's strange, but the boy stubbornly says that everything is right. So help him and find the desired unfairness for received numbers.
Input
The input consists of multiple test cases. The first line contains one integer t (1 ≤ t ≤ 10 000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains a single integer n (1 ≤ n ≤ 10^{18}).
Output
Output t lines. For each test case, you should output a single line with one integer — the unfairness of the contest if the rating sequence equals to 0, 1, ..., n - 1, n.
Example
Input
5
5
7
11
1
2000000000000
Output
8
11
19
1
3999999999987
Note
For n = 5 we calculate unfairness of the following sequence (numbers from 0 to 5 written in binary with extra leading zeroes, so they all have the same length):
* 000
* 001
* 010
* 011
* 100
* 101
The differences are equal to 1, 2, 1, 3, 1 respectively, so unfairness is equal to 1 + 2 + 1 + 3 + 1 = 8.
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
const double eps = 1e-1;
const long long mod = 1e9 + 7;
bool check_pow_2(long long n) { return (n & (n - 1) == 0); }
bool is_prime(long long a, long long p) {
for (long long i = 2; i <= sqrt(a) && i <= p; i++)
if (a % i == 0) return false;
return true;
}
long long div_up(long long x, long long y) {
if (x == 0) return 0;
return (x - 1) / y + 1;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long ans = 0;
for (long long i = 0; i < 61; i++)
if ((n & (1LL << i)) > 0) ans += (1LL << i + 1) - 1;
cout << ans << '\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.
|
import java.util.*;
import java.io.*;
/*
-> Written by <-
-----------
|J_O_B_E_E_L|
|___________|
| ___ |
| (^_^) |
| /( | )\ |
|____|_|____|
*/
public class Test{
static int x;
static Boolean [][] memo;
static ArrayList<Integer> list;
static boolean dp(int idx,int n) {
if(idx==list.size()) return n==x/2;
if(memo[idx][n]!=null) return memo[idx][n];
return memo[idx][n]=dp(idx+1, n+list.get(idx)) || dp(idx+1, n);
}
public static void main(String[] args) throws IOException {
int t=sc.nextInt();
while(t-->0) {
x=sc.nextInt()*2;
int [] arr=sc.nextIntArray(x);
list=new ArrayList<>();
int i=0;
while(i<x) {
int c=1;
int j=i;
while(i<x-1 && arr[j]>arr[i+1]) {i++; c++;}
list.add(c);
i++;
}
memo=new Boolean[list.size()][x];
pw.println(dp(0, 0)?"Yes":"No");
}
pw.flush();
pw.close();
}
static class Scanner {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public Scanner(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public Integer [] sortedIntArray(int n) {
Integer[] a = new Integer[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
Arrays.sort(a);
return a;
}
public Long [] sortedLongArray(int n) {
Long[] a = new Long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
Arrays.sort(a);
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
}
static Scanner sc = new Scanner(System.in);
static PrintWriter pw = new PrintWriter(System.out);
}
|
Mr. Chanek The Ninja is one day tasked with a mission to handle mad snakes that are attacking a site. Now, Mr. Chanek already arrived at the hills where the destination is right below these hills. The mission area can be divided into a grid of size 1000 × 1000 squares. There are N mad snakes on the site, the i'th mad snake is located on square (X_i, Y_i) and has a danger level B_i.
Mr. Chanek is going to use the Shadow Clone Jutsu and Rasengan that he learned from Lord Seventh to complete this mission. His attack strategy is as follows:
1. Mr. Chanek is going to make M clones.
2. Each clone will choose a mad snake as the attack target. Each clone must pick a different mad snake to attack.
3. All clones jump off the hills and attack their respective chosen target at once with Rasengan of radius R. If the mad snake at square (X, Y) is attacked with a direct Rasengan, it and all mad snakes at squares (X', Y') where max(|X' - X|, |Y' - Y|) ≤ R will die.
4. The real Mr. Chanek will calculate the score of this attack. The score is defined as the square of the sum of the danger levels of all the killed snakes.
Now Mr. Chanek is curious, what is the sum of scores for every possible attack strategy? Because this number can be huge, Mr. Chanek only needs the output modulo 10^9 + 7.
Input
The first line contains three integers N M R (1 ≤ M ≤ N ≤ 2 ⋅ 10^3, 0 ≤ R < 10^3), the number of mad snakes, the number of clones, and the radius of the Rasengan.
The next N lines each contains three integers, X_i, Y_i, dan B_i (1 ≤ X_i, Y_i ≤ 10^3, 1 ≤ B_i ≤ 10^6). It is guaranteed that no two mad snakes occupy the same square.
Output
A line with an integer that denotes the sum of scores for every possible attack strategy.
Example
Input
4 2 1
1 1 10
2 2 20
2 3 30
5 2 40
Output
33800
Note
Here is the illustration of all six possible attack strategies. The circles denote the chosen mad snakes, and the blue squares denote the region of the Rasengan:
<image>
So, the total score of all attacks is: 3.600 + 3.600 + 4.900 + 3.600 + 10.000 + 8.100 = 33.800.
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e3 + 5;
const long long MOD = 1e9 + 7;
long long n, m, R, x[MAXN], y[MAXN], T[MAXN][MAXN], W[MAXN][MAXN],
U[MAXN][MAXN], V[MAXN][MAXN];
long long c[MAXN], inve[MAXN], fact[MAXN];
void read_input() {
cin >> n >> m >> R;
for (long long i = 0; i < n; i++) {
cin >> x[i] >> y[i] >> c[i];
T[x[i]][y[i]]++;
}
}
long long get_cnt(long long l, long long r, long long l2, long long r2) {
l2 = max(1LL, l2);
r2 = max(1LL, r2);
l = min(1000LL, l);
r = min(1000LL, r);
if (l < l2 || r < r2) return 0;
return T[l][r] - T[l][r2 - 1] - T[l2 - 1][r] + T[l2 - 1][r2 - 1];
}
long long add(long long f, long long s) {
f += s;
if (f >= MOD) f %= MOD;
if (f < 0) f += MOD;
return f;
}
long long subs(long long f, long long s) {
f -= s;
if (f >= MOD) f %= MOD;
if (f < 0) f += MOD;
return f;
}
long long mul(long long f, long long s) {
f *= s;
if (f >= MOD) f %= MOD;
if (f < 0) f += MOD;
return f;
}
long long pw(long long f, long long y) {
long long ans = 1;
long long temp = f;
while (y) {
if (y & 1) {
ans = mul(temp, ans);
}
temp = mul(temp, temp);
y >>= 1;
}
return ans;
}
long long inv(long long f) { return pw(f, MOD - 2); }
long long comb(long long f, long long s) {
if (f < s) return 0;
return mul(fact[f], mul(inve[s], inve[f - s]));
}
void solve() {
fact[0] = 1;
inve[0] = inv(1);
for (long long i = 1; i < MAXN; i++) {
fact[i] = mul(i, fact[i - 1]);
inve[i] = inv(fact[i]);
}
for (long long i = 1; i < MAXN; i++) {
for (long long j = 1; j < MAXN; j++) {
T[i][j] += T[i][j - 1] + T[i - 1][j] - T[i - 1][j - 1];
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
for (long long j = i; j < n; j++) {
long long r = max(x[i], x[j]), l = max(y[i], y[j]), r2 = min(x[i], x[j]),
l2 = min(y[i], y[j]);
W[i][j] = get_cnt(r2 + R, l2 + R, r - R, l - R);
V[i][j] = get_cnt(x[i] + R, y[i] + R, x[i] - R, y[i] - R) - W[i][j];
U[i][j] = get_cnt(x[j] + R, y[j] + R, x[j] - R, y[j] - R) - W[i][j];
long long times = 0;
times = subs(comb(n, m), comb(n - W[i][j], m));
long long n2 = n - W[i][j];
times = add(times, add(subs(comb(n2, m), comb(n2 - U[i][j], m)),
add(-comb(n2 - V[i][j], m),
comb(n2 - V[i][j] - U[i][j], m))));
if (i == j)
ans = add(ans, mul(times, mul(c[i], c[i])));
else
ans = add(ans, mul(mul(2, times), mul(c[i], c[j])));
}
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
read_input();
solve();
return 0;
}
|
You are given a rectangular grid with n rows and m columns. The cell located on the i-th row from the top and the j-th column from the left has a value a_{ij} written in it.
You can perform the following operation any number of times (possibly zero):
* Choose any two adjacent cells and multiply the values in them by -1. Two cells are called adjacent if they share a side.
Note that you can use a cell more than once in different operations.
You are interested in X, the sum of all the numbers in the grid.
What is the maximum X you can achieve with these operations?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n,m (2 ≤ n, m ≤ 10).
The following n lines contain m integers each, the j-th element in the i-th line is a_{ij} (-100≤ a_{ij}≤ 100).
Output
For each testcase, print one integer X, the maximum possible sum of all the values in the grid after applying the operation as many times as you want.
Example
Input
2
2 2
-1 1
1 1
3 4
0 -1 -2 -3
-1 -2 -3 -4
-2 -3 -4 -5
Output
2
30
Note
In the first test case, there will always be at least one -1, so the answer is 2.
In the second test case, we can use the operation six times to elements adjacent horizontally and get all numbers to be non-negative. So the answer is: 2× 1 + 3×2 + 3× 3 + 2× 4 + 1× 5 = 30.
|
import java.io.*;
import java.util.StringTokenizer;
public class Cft {
public static void main(String[] args) throws IOException {
InputReader in = new InputReader(System.in);
int t = in.nextInt();
while (t-- > 0) {
int sum=0, min = Integer.MAX_VALUE;
int n = in.nextInt(), m = in.nextInt();
int nh = 0;
for (int i = 0; i < n * m; i++) {
int si = in.nextInt();
if (si<0)
nh++;
sum+= Math.abs(si);
min=Math.min(min,Math.abs(si));
}
if (nh%2 != 0)
sum -= min*2;
System.out.println(sum);
}
}
}
class InputReader {
BufferedReader br;
StringTokenizer st;
public InputReader(InputStream stream) {
br = new BufferedReader(new InputStreamReader(stream));
}
public String nextToken() {
while (st == null || !st.hasMoreTokens()) {
String line = null;
try {
line = br.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
if (line == null) {
return null;
}
st = new StringTokenizer(line);
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(nextToken());
}
public double nextDouble(){
return Double.parseDouble(nextToken());
}
public long nextLong(){
return Long.parseLong(nextToken());
}
}
|
For the New Year, Polycarp decided to send postcards to all his n friends. He wants to make postcards with his own hands. For this purpose, he has a sheet of paper of size w × h, which can be cut into pieces.
Polycarp can cut any sheet of paper w × h that he has in only two cases:
* If w is even, then he can cut the sheet in half and get two sheets of size w/2 × h;
* If h is even, then he can cut the sheet in half and get two sheets of size w × h/2;
If w and h are even at the same time, then Polycarp can cut the sheet according to any of the rules above.
After cutting a sheet of paper, the total number of sheets of paper is increased by 1.
Help Polycarp to find out if he can cut his sheet of size w × h at into n or more pieces, using only the rules described above.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
Each test case consists of one line containing three integers w, h, n (1 ≤ w, h ≤ 10^4, 1 ≤ n ≤ 10^9) — the width and height of the sheet Polycarp has and the number of friends he needs to send a postcard to.
Output
For each test case, output on a separate line:
* "YES", if it is possible to cut a sheet of size w × h into at least n pieces;
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
5
2 2 3
3 3 2
5 10 2
11 13 1
1 4 4
Output
YES
NO
YES
YES
YES
Note
In the first test case, you can first cut the 2 × 2 sheet into two 2 × 1 sheets, and then cut each of them into two more sheets. As a result, we get four sheets 1 × 1. We can choose any three of them and send them to our friends.
In the second test case, a 3 × 3 sheet cannot be cut, so it is impossible to get two sheets.
In the third test case, you can cut a 5 × 10 sheet into two 5 × 5 sheets.
In the fourth test case, there is no need to cut the sheet, since we only need one sheet.
In the fifth test case, you can first cut the 1 × 4 sheet into two 1 × 2 sheets, and then cut each of them into two more sheets. As a result, we get four sheets 1 × 1.
|
import sys
def cardsForFriends():
for _ in range(int(input())):
w, h, n = map(int, input().split())
ans, tmp = 1, 1
while not w & 1:
w //= 2
ans += tmp
tmp *= 2
while not h & 1:
h //= 2
ans += tmp
tmp *= 2
if ans >= n:
print('YES')
else: print('NO')
def main():
cardsForFriends()
if __name__ == "__main__":
main()
|
Gaurang has grown up in a mystical universe. He is faced by n consecutive 2D planes. He shoots a particle of decay age k at the planes.
A particle can pass through a plane directly, however, every plane produces an identical copy of the particle going in the opposite direction with a decay age k-1. If a particle has decay age equal to 1, it will NOT produce a copy.
For example, if there are two planes and a particle is shot with decay age 3 (towards the right), the process is as follows: (here, D(x) refers to a single particle with decay age x)
1. the first plane produces a D(2) to the left and lets D(3) continue on to the right;
2. the second plane produces a D(2) to the left and lets D(3) continue on to the right;
3. the first plane lets D(2) continue on to the left and produces a D(1) to the right;
4. the second plane lets D(1) continue on to the right (D(1) cannot produce any copies).
In total, the final multiset S of particles is \\{D(3), D(2), D(2), D(1)\}. (See notes for visual explanation of this test case.)
Gaurang is unable to cope up with the complexity of this situation when the number of planes is too large. Help Gaurang find the size of the multiset S, given n and k.
Since the size of the multiset can be very large, you have to output it modulo 10^9+7.
Note: Particles can go back and forth between the planes without colliding with each other.
Input
The first line of the input contains the number of test cases t (1 ≤ t ≤ 100). Then, t lines follow, each containing two integers n and k (1 ≤ n, k ≤ 1000).
Additionally, the sum of n over all test cases will not exceed 1000, and the sum of k over all test cases will not exceed 1000. All test cases in one test are different.
Output
Output t integers. The i-th of them should be equal to the answer to the i-th test case.
Examples
Input
4
2 3
2 2
3 1
1 3
Output
4
3
1
2
Input
3
1 1
1 500
500 250
Output
1
2
257950823
Note
Let us explain the first example with four test cases.
Test case 1: (n = 2, k = 3) is already explained in the problem statement.
See the below figure of this simulation. Each straight line with a different color represents the path of a different particle. As you can see, there are four distinct particles in the multiset. Note that the vertical spacing between reflected particles is for visual clarity only (as mentioned before, no two distinct particles collide with each other)
<image>
Test case 2: (n = 2, k = 2) is explained as follows:
1. the first plane produces a D(1) to the left and lets D(2) continue on to the right;
2. the second plane produces a D(1) to the left and lets D(2) continue on to the right;
3. the first plane lets D(1) continue on to the left (D(1) cannot produce any copies).
Total size of multiset obtained \\{D(1), D(1), D(2)\} is equal to three.
Test case 3: (n = 3, k = 1), there are three planes, but decay age is only one. So no new copies are produced while the one particle passes through the planes. Hence, the answer is one.
Test case 4: (n = 1, k = 3) there is only one plane. The particle produces a new copy to the left. The multiset \\{D(2), D(3)\} is of size two.
|
import java.io.*;
import java.util.*;
import java.math.*;
import java.math.BigInteger;
//import javafx.util.*;
public final class B
{
static StringBuilder ans=new StringBuilder();
static FastReader in=new FastReader();
static ArrayList<ArrayList<Integer>> g,CARS,intersection;
static long mod=1000000007;
static int D1[],D2[],par[];
static boolean set[];
static long INF=Long.MAX_VALUE;
static long dp_R[][],dp_L[][];
public static void main(String args[])throws IOException
{
int T=i();
while(T-->0)
{
int N=i(),K=i();
dp_L=new long[N][K+1];
dp_R=new long[N][K+1];
for(int i=0; i<N; i++)
{
Arrays.fill(dp_L[i], -1);
Arrays.fill(dp_R[i], -1);
}
System.out.println(f(0,K,true));
}
}
static long f(int index,int K,boolean f)
{
if(K==1)return 1;
boolean l=true,r=true;
if(index==0)l=false;
if(index+1==dp_L.length)r=false;
if(f)
{
//dp_R will be used
if(dp_R[index][K]==-1)
{
long a=1,b=1;
if(r)a=f(index+1,K,f);
if(l)b=f(index-1,K-1,f^true);
dp_R[index][K]=(a%mod+b%mod)%mod;
}
return dp_R[index][K];
}
else
{
if(dp_L[index][K]==-1)
{
long a=1,b=1;
if(r)a=f(index+1,K-1,f^true);
if(l)b=f(index-1,K,f);
dp_L[index][K]=(a%mod+b%mod)%mod;
}
return dp_L[index][K];
}
}
static boolean isValid(char X[],int l,int N)
{
int r=N-l; r--;
//System.out.println(l+" "+r);
if(r>=(l+1))
{
for(int i=0; i<=l; i++)
{
if(X[i]!=X[i+l+1])return false;
}
return true;
}
return false;
}
static boolean ispalin(char X[],int l,int r)
{
while(l<r)
{
if(X[l]!=X[r])return false;
l++; r--;
}
return true;
}
static long min(long a,long b,long c)
{
return Math.min(a, Math.min(c, b));
}
static void dfs(int n)
{
set[n]=true;
for(int c:g.get(n))
{
if(!set[c])dfs(c);
}
}
static void print(int a)
{
System.out.println("! "+a);
}
static int ask(int a,int b)
{
System.out.println("? "+a+" "+b);
return i();
}
static int find(int a)
{
if(par[a]<0)return a;
return par[a]=find(par[a]);
}
static void union(int a,int b)
{
a=find(a);
b=find(b);
if(a!=b)
{
par[a]+=par[b]; //transfers the size
par[b]=a; //changes the parent
}
}
static ArrayList<Integer> IND(int B[],HashMap<Integer,Integer> mp)
{
ArrayList<Integer> A=new ArrayList<>();
for(int i:B)
{
if(mp.containsKey(i))
{
A.add(i);
int f=mp.get(i)-1;
if(f==0)
mp.remove(i);
else mp.put(i, f);
}
}
return A;
}
static HashMap<Integer,Integer> hash(int A[],int index)
{
HashMap<Integer,Integer> mp=new HashMap<Integer,Integer>();
for(int i=index; i<A.length; i++)
{
int f=mp.getOrDefault(A[i], 0)+1;
mp.put(A[i], f);
}
return mp;
}
static void swap(char A[],int a,int b)
{
char ch=A[a];
A[a]=A[b];
A[b]=ch;
}
static long lower_Bound(long A[],int low,int high, long x)
{
if (low > high)
if (x >= A[high])
return A[high];
int mid = (low + high) / 2;
if (A[mid] == x)
return A[mid];
if (mid > 0 && A[mid - 1] <= x && x < A[mid])
return A[mid - 1];
if (x < A[mid])
return lower_Bound( A, low, mid - 1, x);
return lower_Bound(A, mid + 1, high, x);
}
static void sort(long[] a) //check for long
{
ArrayList<Long> l=new ArrayList<>();
for (long i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static void setGraph(int N)
{
g=new ArrayList<ArrayList<Integer>>();
intersection=new ArrayList<ArrayList<Integer>>();
CARS=new ArrayList<ArrayList<Integer>>();
for(int i=0; i<=N; i++)
{
CARS.add(new ArrayList<Integer>());
intersection.add(new ArrayList<Integer>());
g.add(new ArrayList<Integer>());
}
}
static long pow(long a,long b)
{
long mod=1000000007;
long pow=1;
long x=a;
while(b!=0)
{
if((b&1)!=0)pow=(pow*x)%mod;
x=(x*x)%mod;
b/=2;
}
return pow;
}
static long toggleBits(long x)//one's complement || Toggle bits
{
int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
return ((1<<n)-1)^x;
}
static int countBits(long a)
{
return (int)(Math.log(a)/Math.log(2)+1);
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static boolean isPrime(long N)
{
if (N<=1) return false;
if (N<=3) return true;
if (N%2 == 0 || N%3 == 0) return false;
for (int i=5; i*i<=N; i=i+6)
if (N%i == 0 || N%(i+2) == 0)
return false;
return true;
}
static long GCD(long a,long b)
{
if(b==0)
{
return a;
}
else return GCD(b,a%b );
}
//Debugging Functions Starts
static void print(char A[])
{
for(char c:A)System.out.print(c+" ");
System.out.println();
}
static void print(boolean A[])
{
for(boolean c:A)System.out.print(c+" ");
System.out.println();
}
static void print(int A[])
{
for(int a:A)System.out.print(a+" ");
System.out.println();
}
static void print(long A[])
{
for(long i:A)System.out.print(i+ " ");
System.out.println();
}
static void print(ArrayList<Integer> A)
{
for(int a:A)System.out.print(a+" ");
System.out.println();
}
//Debugging Functions END
//----------------------
//IO FUNCTIONS STARTS
static HashMap<Integer,Integer> Hash(int A[])
{
HashMap<Integer,Integer> mp=new HashMap<>();
for(int a:A)
{
int f=mp.getOrDefault(a,0)+1;
mp.put(a, f);
}
return mp;
}
static int i()
{
return in.nextInt();
}
static long l()
{
return in.nextLong();
}
static int[] input(int N){
int A[]=new int[N];
for(int i=0; i<N; i++)
{
A[i]=in.nextInt();
}
return A;
}
static long[] inputLong(int N) {
long A[]=new long[N];
for(int i=0; i<A.length; i++)A[i]=in.nextLong();
return A;
}
//IO FUNCTIONS END
}
class pair {
int k,index;
boolean f;
pair(int k,int index,boolean f)
{
this.k=k;
this.index=index;
this.f=f;
}
}
//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader
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());
}
//gey
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str="";
try
{
str=br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
|
Let's call a positive integer n ordinary if in the decimal notation all its digits are the same. For example, 1, 2 and 99 are ordinary numbers, but 719 and 2021 are not ordinary numbers.
For a given number n, find the number of ordinary numbers among the numbers from 1 to n.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case is characterized by one integer n (1 ≤ n ≤ 10^9).
Output
For each test case output the number of ordinary numbers among numbers from 1 to n.
Example
Input
6
1
2
3
4
5
100
Output
1
2
3
4
5
18
|
"""
Don't see the standings during the contest!!! you will lose motivation.
"""
# ---------------------------------------------------Import Libraries---------------------------------------------------
import sys
import time
import os
from math import sqrt, log, log2, ceil, log10, gcd, floor, pow, sin, cos, tan, pi, inf, factorial
from copy import copy, deepcopy
from sys import exit, stdin, stdout
from collections import Counter, defaultdict, deque
from itertools import permutations
import heapq
from bisect import bisect_left as bl
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is r
# ---------------------------------------------------Global Variables---------------------------------------------------
# sys.setrecursionlimit(100000000)
mod = 1000000007
# ---------------------------------------------------Helper Functions---------------------------------------------------
iinp = lambda: int(sys.stdin.readline())
inp = lambda: sys.stdin.readline().strip()
strl = lambda: list(inp().strip().split(" "))
intl = lambda: list(map(int, inp().split(" ")))
mint = lambda: map(int, inp().split())
flol = lambda: list(map(float, inp().split(" ")))
flush = lambda: stdout.flush()
def permute(nums):
def fun(arr, nums, cur, v):
if len(cur) == len(nums):
arr.append(cur.copy())
i = 0
while i < len(nums):
if v[i]:
i += 1
continue
else:
cur.append(nums[i])
v[i] = 1
fun(arr, nums, cur, v)
cur.pop()
v[i] = 0
i += 1
# while i<len(nums) and nums[i]==nums[i-1]:i+=1 # Uncomment for unique permutations
return arr
res = []
nums.sort()
v = [0] * len(nums)
return fun(res, nums, [], v)
def subsets(res, index, arr, cur):
res.append(cur.copy())
for i in range(index, len(arr)):
cur.append(arr[i])
subsets(res, i + 1, arr, cur)
cur.pop()
return res
def sieve(N):
root = int(sqrt(N))
primes = [1] * (N + 1)
primes[0], primes[1] = 0, 0
for i in range(2, root + 1):
if primes[i]:
for j in range(i * i, N + 1, i):
primes[j] = 0
return primes
def bs(arr, l, r, x):
if x < arr[0] or x > arr[len(arr) - 1]:
return -1
while l <= r:
mid = l + (r - l) // 2
if arr[mid] == x:
return mid
elif arr[mid] < x:
l = mid + 1
else:
r = mid - 1
return -1
def isPrime(n):
if n <= 1: return False
if n <= 3: return True
if n % 2 == 0 or n % 3 == 0: return False
p = int(sqrt(n))
for i in range(5, p + 1, 6):
if n % i == 0 or n % (i + 2) == 0:
return False
return True
# -------------------------------------------------------Functions------------------------------------------------------
def solve():
n=iinp()
if 1<=n<=9:
print(n)
return
else:
ans=0
for i in range(1,10):
j=str(i)
while int(j)<=n:
ans+=1
j+=str(i)
print(ans)
# -------------------------------------------------------Main Code------------------------------------------------------
start_time = time.time()
for _ in range(iinp()):
solve()
# print("--- %s seconds ---" % (time.time() - start_time))
|
You are given a directed graph G which can contain loops (edges from a vertex to itself). Multi-edges are absent in G which means that for all ordered pairs (u, v) exists at most one edge from u to v. Vertices are numbered from 1 to n.
A path from u to v is a sequence of edges such that:
* vertex u is the start of the first edge in the path;
* vertex v is the end of the last edge in the path;
* for all pairs of adjacent edges next edge starts at the vertex that the previous edge ends on.
We will assume that the empty sequence of edges is a path from u to u.
For each vertex v output one of four values:
* 0, if there are no paths from 1 to v;
* 1, if there is only one path from 1 to v;
* 2, if there is more than one path from 1 to v and the number of paths is finite;
* -1, if the number of paths from 1 to v is infinite.
Let's look at the example shown in the figure.
<image>
Then:
* the answer for vertex 1 is 1: there is only one path from 1 to 1 (path with length 0);
* the answer for vertex 2 is 0: there are no paths from 1 to 2;
* the answer for vertex 3 is 1: there is only one path from 1 to 3 (it is the edge (1, 3));
* the answer for vertex 4 is 2: there are more than one paths from 1 to 4 and the number of paths are finite (two paths: [(1, 3), (3, 4)] and [(1, 4)]);
* the answer for vertex 5 is -1: the number of paths from 1 to 5 is infinite (the loop can be used in a path many times);
* the answer for vertex 6 is -1: the number of paths from 1 to 6 is infinite (the loop can be used in a path many times).
Input
The first contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow. Before each test case, there is an empty line.
The first line of the test case contains two integers n and m (1 ≤ n ≤ 4 ⋅ 10^5, 0 ≤ m ≤ 4 ⋅ 10^5) — numbers of vertices and edges in graph respectively. The next m lines contain edges descriptions. Each line contains two integers a_i, b_i (1 ≤ a_i, b_i ≤ n) — the start and the end of the i-th edge. The vertices of the graph are numbered from 1 to n. The given graph can contain loops (it is possible that a_i = b_i), but cannot contain multi-edges (it is not possible that a_i = a_j and b_i = b_j for i ≠ j).
The sum of n over all test cases does not exceed 4 ⋅ 10^5. Similarly, the sum of m over all test cases does not exceed 4 ⋅ 10^5.
Output
Output t lines. The i-th line should contain an answer for the i-th test case: a sequence of n integers from -1 to 2.
Example
Input
5
6 7
1 4
1 3
3 4
4 5
2 1
5 5
5 6
1 0
3 3
1 2
2 3
3 1
5 0
4 4
1 2
2 3
1 4
4 3
Output
1 0 1 2 -1 -1
1
-1 -1 -1
1 0 0 0 0
1 1 2 1
|
#include <bits/stdc++.h>
#define forn(i,n) for(ll i=0; i<n; i++)
#define pb push_back
#define ll long long int
#define mp make_pair
#define sz(arr) (ll)arr.size()
#define MOD 998244353
using namespace std;
vector< vector<ll> > tree;
vector<ll> ans,used;
void dfs(ll nd){
used[nd]=1;
//cout<<nd<<" ";
for(ll nxt: tree[nd]){
if (ans[nxt]==0){
ans[nxt]=ans[nd];
dfs(nxt);
}
else{
if (used[nxt]==0 and ans[nxt]==1){
ans[nxt]=2;
dfs(nxt);
}
if (used[nxt]==1 and ans[nxt]!=-1){
ans[nxt]=-1;
//dfs(nxt);
}
}
}
used[nd]=0;
}
void second_dfs(ll nd){
for(ll nxt: tree[nd]){
if (ans[nxt]!=-1){
ans[nxt]=-1;
second_dfs(nxt);
}
}
}
void solve(){
ll n,m;
cin>>n>>m;
tree=vector< vector<ll> > (n);
ll x,y;
forn(i,m){
cin>>x>>y;
x--;y--;
tree[x].pb(y);
}
ans=vector<ll>(n,0);
used=vector<ll>(n);
ans[0]=1;
dfs(0);
forn(i,n) if (ans[i]==-1) second_dfs(i);
forn(i,n) cout<<ans[i]<<" ";
cout<<"\n";
}
int main(){
ll T;
cin>>T;
while (T--){
solve();
}
}
|
Vasya plays the Plane of Tanks.
Tanks are described with the following attributes:
* the number of hit points;
* the interval between two gun shots (the time required to recharge the gun);
* the probability that the gun shot will not pierce armor of the enemy tank;
* the damage to the enemy's tank.
The gun damage is described with a segment [l, r], where l and r are integer numbers. The potential gun damage x is chosen with equal probability among all integer numbers of the segment [l, r]. If the shot pierces the armor of an enemy's tank then the enemy loses x hit points. If the number of hit points becomes non-positive then the enemy tank is considered destroyed.
It is possible that the shot does not pierce the armor of a tank. In this case the number of hit points doesn't change. The probability that the armor will not be pierced is considered as the shooting tank attribute and does not depend on players' behavior.
The victory is near and there is only one enemy tank left. Vasya is ready for the battle — one more battle between the Good and the Evil is inevitable! Two enemies saw each other and each of them fired a shot at the same moment... The last battle has begun! Help Vasya to determine what is the probability that he will win the battle by destroying the enemy tank?
If both tanks are destroyed (after simultaneous shots), then Vasya is considered a winner. You can assume that each player fires a shot just after the gun recharge and each tank has infinite number of ammo.
Input
The first line contains five integer numbers separated with spaces describing Vasya's tank: the number of hit points hp (10 ≤ hp ≤ 200), the interval between two shots dt (1 ≤ dt ≤ 30), gun damage segment l and r (10 ≤ l ≤ r ≤ 100), the probability that the enemy's tank armor will not be pierced p (0 ≤ p ≤ 100) (percents).
The second line describes the tank of Vasya's enemy in the same format.
Output
Print the only number with absolute or relative error no more than 10 - 4 — probability of Vasya's victory.
Examples
Input
100 3 50 50 0
100 3 50 50 0
Output
1.000000
Input
100 3 50 50 0
100 2 48 50 0
Output
0.888889
Input
100 3 50 50 0
100 1 50 50 50
Output
0.500000
Note
In the first example both tanks are destroyed at once after the second shot. The probability of destroying the enemy tank is 1.
In the second example Vasya's enemy tank fires the second shot before Vasya's tank, but has no time for the third shot. In order to destroy Vasya's tank it is necessary to fire two shots with damage 50. The probability of that event is <image> = <image>. Otherwise, Vasya wins.
In the third example Vasya's enemy tank fires three shots with probability of armor piercing 0.5. In order to destroy Vasya's tank it is necessary that at least 2 of 3 shots pierce the armor of Vasya's tank. The probability of this event is 0.5.
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
int hp1, hp2;
int dt1, dt2;
int L1, R1;
int L2, R2;
double p1, p2;
double frac1, frac2;
const int MAXH = 200;
const int D = 5000;
double dp1[MAXH + 1][D + 1];
double dp2[MAXH + 1][D + 1];
double sum1[D + 1];
double sum2[D + 1];
void calcDp(int i, double dp[][D + 1], double p, double frac, int L, int R,
double sum[]) {
for (int j = 0; j <= MAXH; ++j) dp[j][i + 1] = 0.0;
sum[i + 1] = 0;
for (int j = 1; j <= MAXH; ++j) {
if (dp[j][i] < eps) continue;
int h = j - L;
if (h < 0) h = 0;
double mul = p * frac * dp[j][i];
for (int k = L; k <= R; ++k) {
dp[h][i + 1] += mul;
if (h > 0) {
sum[i + 1] += mul;
--h;
}
}
dp[j][i + 1] += (1.0 - p) * dp[j][i];
sum[i + 1] += (1.0 - p) * dp[j][i];
}
}
int main() {
cout.setf(ios::fixed);
cout.precision(9);
int tmp;
cin >> hp1 >> dt1 >> L1 >> R1 >> tmp;
p1 = 1.0 - double(tmp) / 100.0;
if (tmp == 100) {
cout << "0.0" << endl;
return 0;
}
cin >> hp2 >> dt2 >> L2 >> R2 >> tmp;
if (tmp == 100) {
cout << "1.0" << endl;
return 0;
}
p2 = 1.0 - double(tmp) / 100.0;
frac1 = 1.0 / double(R1 - L1 + 1.0);
frac2 = 1.0 / double(R2 - L2 + 1.0);
for (int i = 0; i <= MAXH; ++i) {
dp1[i][0] = 0.0;
dp2[i][0] = 0.0;
}
sum1[0] = 1.0;
sum2[0] = 1.0;
dp1[hp1][0] = 1.0;
dp2[hp2][0] = 1.0;
for (int i = 0; i < D; ++i) {
calcDp(i, dp2, p1, frac1, L1, R1, sum2);
calcDp(i, dp1, p2, frac2, L2, R2, sum1);
}
int next1 = 0;
int next2 = 0;
int done1 = 0;
int done2 = 0;
double ret = 0.0;
while (true) {
if (next1 <= next2) {
if (done1 >= D) break;
double expr = sum1[done2] * dp2[0][done1 + 1];
ret += expr;
++done1;
next1 += dt1;
} else {
if (done2 >= D) break;
++done2;
next2 += dt2;
}
}
cout << ret << endl;
return 0;
}
|
An oriented weighted forest is an acyclic weighted digraph in which from each vertex at most one edge goes.
The root of vertex v of an oriented weighted forest is a vertex from which no edge goes and which can be reached from vertex v moving along the edges of the weighted oriented forest. We denote the root of vertex v as root(v).
The depth of vertex v is the sum of weights of paths passing from the vertex v to its root. Let's denote the depth of the vertex v as depth(v).
Let's consider the process of constructing a weighted directed forest. Initially, the forest does not contain vertices. Vertices are added sequentially one by one. Overall, there are n performed operations of adding. The i-th (i > 0) adding operation is described by a set of numbers (k, v1, x1, v2, x2, ... , vk, xk) and means that we should add vertex number i and k edges to the graph: an edge from vertex root(v1) to vertex i with weight depth(v1) + x1, an edge from vertex root(v2) to vertex i with weight depth(v2) + x2 and so on. If k = 0, then only vertex i is added to the graph, there are no added edges.
Your task is like this: given the operations of adding vertices, calculate the sum of the weights of all edges of the forest, resulting after the application of all defined operations, modulo 1000000007 (109 + 7).
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of operations of adding a vertex.
Next n lines contain descriptions of the operations, the i-th line contains the description of the operation of adding the i-th vertex in the following format: the first number of a line is an integer k (0 ≤ k ≤ i - 1), then follow 2k space-separated integers: v1, x1, v2, x2, ... , vk, xk (1 ≤ vj ≤ i - 1, |xj| ≤ 109).
The operations are given in the order, in which they should be applied to the graph. It is guaranteed that sum k of all operations does not exceed 105, also that applying operations of adding vertexes does not result in loops and multiple edges.
Output
Print a single number — the sum of weights of all edges of the resulting graph modulo 1000000007 (109 + 7).
Examples
Input
6
0
0
1 2 1
2 1 5 2 2
1 1 2
1 3 4
Output
30
Input
5
0
1 1 5
0
0
2 3 1 4 3
Output
9
Note
Conside the first sample:
1. Vertex 1 is added. k = 0, thus no edges are added.
2. Vertex 2 is added. k = 0, thus no edges are added.
3. Vertex 3 is added. k = 1. v1 = 2, x1 = 1. Edge from vertex root(2) = 2 to vertex 3 with weight depth(2) + x1 = 0 + 1 = 1 is added.
4. Vertex 4 is added. k = 2. v1 = 1, x1 = 5. Edge from vertex root(1) = 1 to vertex 4 with weight depth(1) + x1 = 0 + 5 = 5 is added. v2 = 2, x2 = 2. Edge from vertex root(2) = 3 to vertex 4 with weight depth(2) + x1 = 1 + 2 = 3 is added.
5. Vertex 5 is added. k = 1. v1 = 1, x1 = 2. Edge from vertex root(1) = 4 to vertex 5 with weight depth(1) + x1 = 5 + 2 = 7 is added.
6. Vertex 6 is added. k = 1. v1 = 3, x1 = 4. Edge from vertex root(3) = 5 to vertex 6 with weight depth(3) + x1 = 10 + 4 = 14 is added.
The resulting graph is shown on the pictore below: <image>
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100 * 1000 + 10;
const long long D = 1000ll * 1000 * 1000 + 7;
pair<int, long long> par[Maxn];
pair<int, long long> find(int v) {
if (v == par[v].first) return par[v];
pair<int, long long> ret = find(par[v].first);
par[v] = pair<int, long long>(ret.first,
(((ret.second + par[v].second) % D) + D) % D);
return par[v];
}
long long n, ret;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
long long k, v, x;
cin >> k;
par[i].first = i;
for (int j = 0; j < k; j++) {
cin >> v >> x;
find(v);
ret = (((ret + x + par[v].second) % D) + D) % D;
par[par[v].first] = pair<int, long long>(i, par[v].second + x);
}
}
cout << ret << endl;
return 0;
}
|
A parking lot in the City consists of n parking spaces, standing in a line. The parking spaces are numbered from 1 to n from left to right.
When a car arrives at the lot, the operator determines an empty parking space for it. For the safety's sake the chosen place should be located as far from the already occupied places as possible. That is, the closest occupied parking space must be as far away as possible. If there are several such places, then the operator chooses the place with the minimum index from them. If all parking lot places are empty, then the car gets place number 1.
We consider the distance between the i-th and the j-th parking spaces equal to 4·|i - j| meters.
You are given the parking lot records of arriving and departing cars in the chronological order. For each record of an arriving car print the number of the parking lot that was given to this car.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 2·105) — the number of parking places and the number of records correspondingly.
Next m lines contain the descriptions of the records, one per line. The i-th line contains numbers ti, idi (1 ≤ ti ≤ 2; 1 ≤ idi ≤ 106). If ti equals 1, then the corresponding record says that the car number idi arrived at the parking lot. If ti equals 2, then the corresponding record says that the car number idi departed from the parking lot.
Records about arriving to the parking lot and departing from the parking lot are given chronologically. All events occurred consecutively, no two events occurred simultaneously.
It is guaranteed that all entries are correct:
* each car arrived at the parking lot at most once and departed from the parking lot at most once,
* there is no record of a departing car if it didn't arrive at the parking lot earlier,
* there are no more than n cars on the parking lot at any moment.
You can consider the cars arbitrarily numbered from 1 to 106, all numbers are distinct. Initially all places in the parking lot are empty.
Output
For each entry of an arriving car print the number of its parking space. Print the numbers of the spaces in the order, in which the cars arrive to the parking lot.
Examples
Input
7 11
1 15
1 123123
1 3
1 5
2 123123
2 15
1 21
2 3
1 6
1 7
1 8
Output
1
7
4
2
7
4
1
3
|
#include <bits/stdc++.h>
using namespace std;
int n, q, lt, rt, a, b, place, arabayeri[1000009], sol[1000009], sag[1000009],
temp2;
set<pair<int, pair<int, int> > > A;
pair<int, int> temp;
pair<int, pair<int, int> > f(int l, int r) {
if (!l and r == n + 1) return make_pair(-1e9, make_pair(1, n + 1));
if (!l) return make_pair(-r + 1, make_pair(1, r));
if (r == n + 1) return make_pair(-n + l, make_pair(n, n + 1));
return make_pair(-(r - l) / 2, make_pair((r + l) / 2, r));
}
int main() {
cin >> n >> q;
A.insert(f(0, n + 1));
sag[0] = n + 1;
sol[n + 1] = 0;
for (int i = 1; i <= q; i++) {
cin >> a >> b;
if (a == 1) {
temp = A.begin()->second;
A.erase(A.begin());
place = temp.first;
rt = temp.second;
lt = sol[rt];
sol[place] = lt;
sag[place] = rt;
sol[rt] = sag[lt] = place;
cout << place << endl;
arabayeri[b] = place;
A.insert(f(lt, place));
A.insert(f(place, rt));
}
if (a == 2) {
temp2 = arabayeri[b];
lt = sol[temp2];
rt = sag[temp2];
sol[rt] = lt;
sag[lt] = rt;
A.erase(f(lt, temp2));
A.erase(f(temp2, rt));
A.insert(f(lt, rt));
}
}
}
|
One day Petya got a birthday present from his mom: a book called "The Legends and Myths of Graph Theory". From this book Petya learned about a hydra graph.
A non-oriented graph is a hydra, if it has a structure, shown on the figure below. Namely, there are two nodes u and v connected by an edge, they are the hydra's chest and stomach, correspondingly. The chest is connected with h nodes, which are the hydra's heads. The stomach is connected with t nodes, which are the hydra's tails. Note that the hydra is a tree, consisting of h + t + 2 nodes.
<image>
Also, Petya's got a non-directed graph G, consisting of n nodes and m edges. Petya got this graph as a last year birthday present from his mom. Graph G contains no self-loops or multiple edges.
Now Petya wants to find a hydra in graph G. Or else, to make sure that the graph doesn't have a hydra.
Input
The first line contains four integers n, m, h, t (1 ≤ n, m ≤ 105, 1 ≤ h, t ≤ 100) — the number of nodes and edges in graph G, and the number of a hydra's heads and tails.
Next m lines contain the description of the edges of graph G. The i-th of these lines contains two integers ai and bi (1 ≤ ai, bi ≤ n, a ≠ b) — the numbers of the nodes, connected by the i-th edge.
It is guaranteed that graph G contains no self-loops and multiple edges. Consider the nodes of graph G numbered with integers from 1 to n.
Output
If graph G has no hydra, print "NO" (without the quotes).
Otherwise, in the first line print "YES" (without the quotes). In the second line print two integers — the numbers of nodes u and v. In the third line print h numbers — the numbers of the nodes that are the heads. In the fourth line print t numbers — the numbers of the nodes that are the tails. All printed numbers should be distinct.
If there are multiple possible answers, you are allowed to print any of them.
Examples
Input
9 12 2 3
1 2
2 3
1 3
1 4
2 5
4 5
4 6
6 5
6 7
7 5
8 7
9 1
Output
YES
4 1
5 6
9 3 2
Input
7 10 3 3
1 2
2 3
1 3
1 4
2 5
4 5
4 6
6 5
6 7
7 5
Output
NO
Note
The first sample is depicted on the picture below:
<image>
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
vector<int> e[N], e1[N];
int used[N], n, m, h, t;
void check(int v, int u) {
int k1, k2, k3 = k1 = k2 = 0;
static int timer = 10;
timer++;
for (int to : e[v]) {
if (to == u) {
continue;
}
used[to] = timer;
k1++;
}
for (int to : e[u]) {
if (to == v) {
continue;
}
k3 += used[to] == timer;
used[to] = -timer;
k2++;
}
k1 -= k3;
k2 -= k3;
if (k1 < h) {
int take = min(h - k1, k3);
k3 -= take;
k1 += take;
}
k2 += k3;
if (k1 < h || k2 < t) {
return;
}
vector<char> flag(n);
vector<int> a, b, c;
for (int to : e[v]) {
if (to != u && used[to] != -timer) {
a.push_back(to);
}
used[to] = timer;
}
for (int to : e[u]) {
if (to == v) {
continue;
}
if (used[to] == timer) {
c.push_back(to);
} else {
b.push_back(to);
}
}
printf("YES\n%d %d\n", v + 1, u + 1);
while (h--)
if (!a.empty()) {
printf("%d ", a.back() + 1);
a.pop_back();
} else {
printf("%d ", c.back() + 1);
c.pop_back();
}
printf("\n");
while (t--)
if (!b.empty()) {
printf("%d ", b.back() + 1);
b.pop_back();
} else {
printf("%d ", c.back() + 1);
c.pop_back();
}
exit(0);
}
int main() {
scanf("%d%d%d%d", &n, &m, &h, &t);
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
e1[x].push_back(y);
e1[y].push_back(x);
if (e[x].size() < h + t + 2) {
e[x].push_back(y);
}
if (e[y].size() < h + t + 2) {
e[y].push_back(x);
}
}
for (int v = 0; v < n; v++)
for (int to : e1[v]) {
check(v, to);
}
printf("NO");
return 0;
}
|
Manao's friends often send him new songs. He never listens to them right away. Instead, he compiles them into a playlist. When he feels that his mind is open to new music, he opens the playlist and starts to listen to the songs.
Of course, there are some songs that Manao doesn't particuarly enjoy. To get more pleasure from the received songs, he invented the following procedure of listening to the playlist:
* If after listening to some song Manao realizes that he liked it, then he remembers it and starts to listen to the next unlistened song.
* If after listening to some song Manao realizes that he did not like it, he listens to all the songs he liked up to this point and then begins to listen to the next unlistened song.
For example, if Manao has four songs in the playlist, A, B, C, D (in the corresponding order) and he is going to like songs A and C in the end, then the order of listening is the following:
1. Manao listens to A, he likes it, he remembers it.
2. Manao listens to B, he does not like it, so he listens to A, again.
3. Manao listens to C, he likes the song and he remembers it, too.
4. Manao listens to D, but does not enjoy it and re-listens to songs A and C.
That is, in the end Manao listens to song A three times, to song C twice and songs B and D once. Note that if Manao once liked a song, he will never dislike it on a subsequent listening.
Manao has received n songs: the i-th of them is li seconds long and Manao may like it with a probability of pi percents. The songs could get on Manao's playlist in any order, so Manao wants to know the maximum expected value of the number of seconds after which the listening process will be over, for all possible permutations of the songs in the playlist.
Input
The first line contains a single integer n (1 ≤ n ≤ 50000). The i-th of the following n lines contains two integers, separated by a single space — li and pi (15 ≤ li ≤ 1000, 0 ≤ pi ≤ 100) — the length of the i-th song in seconds and the probability that Manao will like the song, in percents.
Output
In a single line print a single real number — the maximum expected listening time over all permutations of songs. The answer will be considered valid if the absolute or relative error does not exceed 10 - 9.
Examples
Input
3
150 20
150 50
100 50
Output
537.500000000
Input
4
300 0
300 50
240 50
360 80
Output
2121.000000000
Note
Consider the first test case. If Manao listens to the songs in the order in which they were originally compiled, the mathematical expectation will be equal to 467.5 seconds. The maximum expected value is obtained by putting the first song at the end of the playlist.
Consider the second test case. The song which is 360 seconds long should be listened to first. The song 300 seconds long which Manao will dislike for sure should be put in the end.
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 5 * 10000 + 10, mod = (int)1e9 + 7;
int n;
long double k = 0, s = 0, lll, pp;
int p[maxN], l[maxN];
pair<int, int> c[maxN];
bool cmp(pair<int, int> x, pair<int, int> y) {
double xxx, yyy;
if (x.second != 100)
xxx = (double)(x.first * x.second) / (100 - x.second);
else
return 1;
if (y.second != 100)
yyy = (double)(y.first * y.second) / (100 - y.second);
else
return 0;
return xxx > yyy;
}
int main(void) {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> c[i].first >> c[i].second;
sort(c, c + n, cmp);
for (int i = 0; i < n; ++i) {
lll = (double)c[i].first;
pp = (double)c[i].second;
s += lll;
s += (k * (100 - pp)) / 100;
k += (lll * pp) / 100;
}
printf("%.9lf", s);
return 0;
}
|
The problem describes the properties of a command line. The description somehow resembles the one you usually see in real operating systems. However, there are differences in the behavior. Please make sure you've read the statement attentively and use it as a formal document.
In the Pindows operating system a strings are the lexemes of the command line — the first of them is understood as the name of the program to run and the following lexemes are its arguments. For example, as we execute the command " run.exe one, two . ", we give four lexemes to the Pindows command line: "run.exe", "one,", "two", ".". More formally, if we run a command that can be represented as string s (that has no quotes), then the command line lexemes are maximal by inclusion substrings of string s that contain no spaces.
To send a string with spaces or an empty string as a command line lexeme, we can use double quotes. The block of characters that should be considered as one lexeme goes inside the quotes. Embedded quotes are prohibited — that is, for each occurrence of character """ we should be able to say clearly that the quotes are opening or closing. For example, as we run the command ""run.exe o" "" " ne, " two . " " ", we give six lexemes to the Pindows command line: "run.exe o", "" (an empty string), " ne, ", "two", ".", " " (a single space).
It is guaranteed that each lexeme of the command line is either surrounded by spaces on both sides or touches the corresponding command border. One of its consequences is: the opening brackets are either the first character of the string or there is a space to the left of them.
You have a string that consists of uppercase and lowercase English letters, digits, characters ".,?!"" and spaces. It is guaranteed that this string is a correct OS Pindows command line string. Print all lexemes of this command line string. Consider the character """ to be used only in order to denote a single block of characters into one command line lexeme. In particular, the consequence is that the given string has got an even number of such characters.
Input
The single line contains a non-empty string s. String s consists of at most 105 characters. Each character is either an uppercase or a lowercase English letter, or a digit, or one of the ".,?!"" signs, or a space.
It is guaranteed that the given string is some correct command line string of the OS Pindows. It is guaranteed that the given command line string contains at least one lexeme.
Output
In the first line print the first lexeme, in the second line print the second one and so on. To make the output clearer, print the "<" (less) character to the left of your lexemes and the ">" (more) character to the right. Print the lexemes in the order in which they occur in the command.
Please, follow the given output format strictly. For more clarifications on the output format see the test samples.
Examples
Input
"RUn.exe O" "" " 2ne, " two! . " "
Output
<RUn.exe O>
<>
< 2ne, >
<two!>
<.>
< >
Input
firstarg second ""
Output
<firstarg>
<second>
<>
|
import java.util.*;
import java.io.*;
import java.awt.Point;
import java.math.BigInteger;
import static java.lang.Math.*;
// Solution is at the bottom of code
public class _B implements Runnable{
final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
BufferedReader in;
OutputWriter out;
StringTokenizer tok = new StringTokenizer("");
public static void main(String[] args){
new Thread(null, new _B(), "", 128 * (1L << 20)).start();
}
/////////////////////////////////////////////////////////////////////
void init() throws FileNotFoundException{
Locale.setDefault(Locale.US);
if (ONLINE_JUDGE){
in = new BufferedReader(new InputStreamReader(System.in));
out = new OutputWriter(System.out);
}else{
in = new BufferedReader(new FileReader("input.txt"));
out = new OutputWriter("output.txt");
}
}
////////////////////////////////////////////////////////////////
long timeBegin, timeEnd;
void time(){
timeEnd = System.currentTimeMillis();
System.err.println("Time = " + (timeEnd - timeBegin));
}
void debug(Object... objects){
if (ONLINE_JUDGE){
for (Object o: objects){
System.err.println(o.toString());
}
}
}
/////////////////////////////////////////////////////////////////////
public void run(){
try{
timeBegin = System.currentTimeMillis();
Locale.setDefault(Locale.US);
init();
solve();
out.close();
time();
}catch (Exception e){
e.printStackTrace(System.err);
System.exit(-1);
}
}
/////////////////////////////////////////////////////////////////////
String delim = " ";
String readString() throws IOException{
while(!tok.hasMoreTokens()){
try{
tok = new StringTokenizer(in.readLine());
}catch (Exception e){
return null;
}
}
return tok.nextToken(delim);
}
String readLine() throws IOException{
return in.readLine();
}
/////////////////////////////////////////////////////////////////
final char NOT_A_SYMBOL = '\0';
char readChar() throws IOException{
int intValue = in.read();
if (intValue == -1){
return NOT_A_SYMBOL;
}
return (char) intValue;
}
char[] readCharArray() throws IOException{
return readLine().toCharArray();
}
/////////////////////////////////////////////////////////////////
int readInt() throws IOException{
return Integer.parseInt(readString());
}
int[] readIntArray(int size) throws IOException{
int[] array = new int[size];
for (int index = 0; index < size; ++index){
array[index] = readInt();
}
return array;
}
///////////////////////////////////////////////////////////////////
long readLong() throws IOException{
return Long.parseLong(readString());
}
long[] readLongArray(int size) throws IOException{
long[] array = new long[size];
for (int index = 0; index < size; ++index){
array[index] = readLong();
}
return array;
}
////////////////////////////////////////////////////////////////////
double readDouble() throws IOException{
return Double.parseDouble(readString());
}
double[] readDoubleArray(int size) throws IOException{
double[] array = new double[size];
for (int index = 0; index < size; ++index){
array[index] = readDouble();
}
return array;
}
/////////////////////////////////////////////////////////////////////
Point readPoint() throws IOException{
return new Point(readInt(), readInt());
}
Point[] readPointArray(int size) throws IOException{
Point[] array = new Point[size];
for (int index = 0; index < size; ++index){
array[index] = readPoint();
}
return array;
}
/////////////////////////////////////////////////////////////////////
List<Integer>[] readGraph(int vertexNumber, int edgeNumber)
throws IOException{
List<Integer>[] graph = new List[vertexNumber];
for (int index = 0; index < vertexNumber; ++index){
graph[index] = new ArrayList<Integer>();
}
while (edgeNumber-- > 0){
int from = readInt() - 1;
int to = readInt() - 1;
graph[from].add(to);
graph[to].add(from);
}
return graph;
}
/////////////////////////////////////////////////////////////////////
class OutputWriter extends PrintWriter{
final int DEFAULT_PRECISION = 12;
int precision;
String format, formatWithSpace;
{
precision = DEFAULT_PRECISION;
format = createFormat(precision);
formatWithSpace = format + " ";
}
public OutputWriter(OutputStream out) {
super(out);
}
public OutputWriter(String fileName) throws FileNotFoundException {
super(fileName);
}
public int getPrecision() {
return precision;
}
public void setPrecision(int precision) {
this.precision = precision;
format = createFormat(precision);
formatWithSpace = format + " ";
}
private String createFormat(int precision){
return "%." + precision + "f";
}
@Override
public void print(double d){
printf(format, d);
}
public void printWithSpace(double d){
printf(formatWithSpace, d);
}
public void printAll(double...d){
for (int i = 0; i < d.length - 1; ++i){
printWithSpace(d[i]);
}
print(d[d.length - 1]);
}
@Override
public void println(double d){
printlnAll(d);
}
public void printlnAll(double... d){
printAll(d);
println();
}
}
/////////////////////////////////////////////////////////////////////
int[][] steps = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
int[][] steps8 = {
{-1, 0}, {1, 0}, {0, -1}, {0, 1},
{-1, -1}, {1, 1}, {1, -1}, {-1, 1}
};
boolean check(int index, int lim){
return (0 <= index && index < lim);
}
/////////////////////////////////////////////////////////////////////
boolean checkBit(int mask, int bitNumber){
return (mask & (1 << bitNumber)) != 0;
}
/////////////////////////////////////////////////////////////////////
void solve() throws IOException{
String input = readLine();
input = input.trim() + " \"a\"";
String[] arguments = input.split("" + '\"');
delim = " ";
for (int stringIndex = 0; stringIndex < arguments.length - 1; ++stringIndex){
String output = arguments[stringIndex];
if (stringIndex % 2 == 1){
out.println("<" + output + ">");
}else{
tok = new StringTokenizer(output.trim());
while (tok.hasMoreTokens()){
String s = tok.nextToken();
if (s == null) break;
if (s.trim().isEmpty()) continue;
out.println("<" + s + ">");
}
}
}
}
}
|
Smart Beaver decided to be not only smart, but also a healthy beaver! And so he began to attend physical education classes at school X. In this school, physical education has a very creative teacher. One of his favorite warm-up exercises is throwing balls. Students line up. Each one gets a single ball in the beginning. The balls are numbered from 1 to n (by the demand of the inventory commission).
<image> Figure 1. The initial position for n = 5.
After receiving the balls the students perform the warm-up exercise. The exercise takes place in a few throws. For each throw the teacher chooses any two arbitrary different students who will participate in it. The selected students throw their balls to each other. Thus, after each throw the students remain in their positions, and the two balls are swapped.
<image> Figure 2. The example of a throw.
In this case there was a throw between the students, who were holding the 2-nd and the 4-th balls. Since the warm-up has many exercises, each of them can only continue for little time. Therefore, for each student we know the maximum number of throws he can participate in. For this lessons maximum number of throws will be 1 or 2.
Note that after all phases of the considered exercise any ball can end up with any student. Smart Beaver decided to formalize it and introduced the concept of the "ball order". The ball order is a sequence of n numbers that correspond to the order of balls in the line. The first number will match the number of the ball of the first from the left student in the line, the second number will match the ball of the second student, and so on. For example, in figure 2 the order of the balls was (1, 2, 3, 4, 5), and after the throw it was (1, 4, 3, 2, 5). Smart beaver knows the number of students and for each student he knows the maximum number of throws in which he can participate. And now he is wondering: what is the number of distinct ways of ball orders by the end of the exercise.
Input
The first line contains a single number n — the number of students in the line and the number of balls. The next line contains exactly n space-separated integers. Each number corresponds to a student in the line (the i-th number corresponds to the i-th from the left student in the line) and shows the number of throws he can participate in.
The input limits for scoring 30 points are (subproblem D1):
* 1 ≤ n ≤ 10.
The input limits for scoring 70 points are (subproblems D1+D2):
* 1 ≤ n ≤ 500.
The input limits for scoring 100 points are (subproblems D1+D2+D3):
* 1 ≤ n ≤ 1000000.
Output
The output should contain a single integer — the number of variants of ball orders after the warm up exercise is complete. As the number can be rather large, print it modulo 1000000007 (109 + 7).
Examples
Input
5
1 2 2 1 2
Output
120
Input
8
1 2 2 1 2 1 1 2
Output
16800
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, mod = 1e9 + 7, ans = 1, f[3];
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &x);
if (x == 1) m++;
}
f[0] = f[1] = 1;
for (long long i = 2; i <= m; i++)
f[i % 3] = (f[(i - 2) % 3] * (i - 1) + f[(i - 1) % 3]) % mod;
for (long long i = n; i > m; i--) ans = ans * i % mod;
printf("%lld", ans * f[(m % 3)] % mod);
return 0;
}
|
Xenia the horse breeder has n (n > 1) horses that stand in a row. Each horse has its own unique number. Initially, the i-th left horse has number i. That is, the sequence of numbers of horses in a row looks as follows (from left to right): 1, 2, 3, ..., n.
Xenia trains horses before the performance. During the practice sessions, she consistently gives them commands. Each command is a pair of numbers l, r (1 ≤ l < r ≤ n). The command l, r means that the horses that are on the l-th, (l + 1)-th, (l + 2)-th, ..., r-th places from the left must be rearranged. The horses that initially stand on the l-th and r-th places will swap. The horses on the (l + 1)-th and (r - 1)-th places will swap. The horses on the (l + 2)-th and (r - 2)-th places will swap and so on. In other words, the horses that were on the segment [l, r] change their order to the reverse one.
For example, if Xenia commanded l = 2, r = 5, and the sequence of numbers of horses before the command looked as (2, 1, 3, 4, 5, 6), then after the command the sequence will be (2, 5, 4, 3, 1, 6).
We know that during the practice Xenia gave at most three commands of the described form. You have got the final sequence of numbers of horses by the end of the practice. Find what commands Xenia gave during the practice. Note that you do not need to minimize the number of commands in the solution, find any valid sequence of at most three commands.
Input
The first line contains an integer n (2 ≤ n ≤ 1000) — the number of horses in the row. The second line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is the number of the i-th left horse in the row after the practice.
Output
The first line should contain integer k (0 ≤ k ≤ 3) — the number of commads Xenia gave during the practice. In each of the next k lines print two integers. In the i-th line print numbers li, ri (1 ≤ li < ri ≤ n) — Xenia's i-th command during the practice.
It is guaranteed that a solution exists. If there are several solutions, you are allowed to print any of them.
Examples
Input
5
1 4 3 2 5
Output
1
2 4
Input
6
2 1 4 3 6 5
Output
3
1 2
3 4
5 6
|
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7;
const long long MAXN = 1e6 + 1;
using namespace std;
long long readInt() {
bool minus1 = false;
long long result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
minus1 = true;
else
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = result * 10 + (ch - '0');
}
if (minus1)
return -result;
else
return result;
}
int a[MAXN];
int n;
vector<pair<int, int> > ans;
void rec(int lvl) {
bool ok = 1;
for (int i = 1; i <= n; i++) {
if (a[i] != i) ok = 0;
}
if (ok) {
cout << ans.size() << '\n';
reverse(ans.begin(), ans.end());
for (pair<int, int> i : ans) {
cout << i.first << ' ' << i.second << '\n';
}
exit(0);
}
if (lvl == 3) {
return;
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (abs(a[i - 1] - a[j]) == 1 || abs(a[j + 1] - a[i]) == 1) {
ans.push_back({i, j});
reverse(a + i, a + j + 1);
rec(lvl + 1);
reverse(a + i, a + j + 1);
ans.pop_back();
}
}
}
}
int main() {
n = readInt();
for (int i = 1; i <= n; i++) {
a[i] = readInt();
}
a[0] = 0;
a[n + 1] = n + 1;
rec(0);
return 0;
}
|
Little boy Petya loves stairs very much. But he is bored from simple going up and down them — he loves jumping over several stairs at a time. As he stands on some stair, he can either jump to the next one or jump over one or two stairs at a time. But some stairs are too dirty and Petya doesn't want to step on them.
Now Petya is on the first stair of the staircase, consisting of n stairs. He also knows the numbers of the dirty stairs of this staircase. Help Petya find out if he can jump through the entire staircase and reach the last stair number n without touching a dirty stair once.
One has to note that anyway Petya should step on the first and last stairs, so if the first or the last stair is dirty, then Petya cannot choose a path with clean steps only.
Input
The first line contains two integers n and m (1 ≤ n ≤ 109, 0 ≤ m ≤ 3000) — the number of stairs in the staircase and the number of dirty stairs, correspondingly. The second line contains m different space-separated integers d1, d2, ..., dm (1 ≤ di ≤ n) — the numbers of the dirty stairs (in an arbitrary order).
Output
Print "YES" if Petya can reach stair number n, stepping only on the clean stairs. Otherwise print "NO".
Examples
Input
10 5
2 4 8 3 6
Output
NO
Input
10 5
2 4 5 7 9
Output
YES
|
import sys
n, m = map(int, input().split())
if m != 0:
data = [int(el) for el in input().split()]
data.sort()
if data[0] == 1 or data[-1] == n:
print('NO')
sys.exit()
for e in range(m - 2):
if data[e] + data[e + 1] + data[e + 2] == data[e] * 3 + 3:
print('NO')
break
else:
print('YES')
else:
print('YES')
|
Our bear's forest has a checkered field. The checkered field is an n × n table, the rows are numbered from 1 to n from top to bottom, the columns are numbered from 1 to n from left to right. Let's denote a cell of the field on the intersection of row x and column y by record (x, y). Each cell of the field contains growing raspberry, at that, the cell (x, y) of the field contains x + y raspberry bushes.
The bear came out to walk across the field. At the beginning of the walk his speed is (dx, dy). Then the bear spends exactly t seconds on the field. Each second the following takes place:
* Let's suppose that at the current moment the bear is in cell (x, y).
* First the bear eats the raspberry from all the bushes he has in the current cell. After the bear eats the raspberry from k bushes, he increases each component of his speed by k. In other words, if before eating the k bushes of raspberry his speed was (dx, dy), then after eating the berry his speed equals (dx + k, dy + k).
* Let's denote the current speed of the bear (dx, dy) (it was increased after the previous step). Then the bear moves from cell (x, y) to cell (((x + dx - 1) mod n) + 1, ((y + dy - 1) mod n) + 1).
* Then one additional raspberry bush grows in each cell of the field.
You task is to predict the bear's actions. Find the cell he ends up in if he starts from cell (sx, sy). Assume that each bush has infinitely much raspberry and the bear will never eat all of it.
Input
The first line of the input contains six space-separated integers: n, sx, sy, dx, dy, t (1 ≤ n ≤ 109; 1 ≤ sx, sy ≤ n; - 100 ≤ dx, dy ≤ 100; 0 ≤ t ≤ 1018).
Output
Print two integers — the coordinates of the cell the bear will end up in after t seconds.
Examples
Input
5 1 2 0 1 2
Output
3 1
Input
1 1 1 -1 -1 2
Output
1 1
Note
Operation a mod b means taking the remainder after dividing a by b. Note that the result of the operation is always non-negative. For example, ( - 1) mod 3 = 2.
In the first sample before the first move the speed vector will equal (3,4) and the bear will get to cell (4,1). Before the second move the speed vector will equal (9,10) and he bear will get to cell (3,1). Don't forget that at the second move, the number of berry bushes increased by 1.
In the second sample before the first move the speed vector will equal (1,1) and the bear will get to cell (1,1). Before the second move, the speed vector will equal (4,4) and the bear will get to cell (1,1). Don't forget that at the second move, the number of berry bushes increased by 1.
|
public class E {
private final static boolean autoflush = false;
long [][] A = {
{ 1, 0, 0, 0, 0, 0 },
{ 1, 1, 0, 0, 0, 0 },
{ 2, 1, 2, 1, 1, 0 },
{ 2, 1, 1, 2, 0, 1 },
{ 2, 1, 1, 1, 1, 0 },
{ 2, 1, 1, 1, 0, 1 }
};
public E () {
int N = sc.nextInt();
int X = sc.nextInt() - 1;
int Y = sc.nextInt() - 1;
int VX = sc.nextInt();
int VY = sc.nextInt();
long T = sc.nextLong();
long [] V = { 1, 0, X, Y, VX, VY };
long [] W = prod(pow(A, T, N), V, N);
exit(W[2] + 1, W[3] + 1);
}
long [] prod(long [][] A, long [] V, long mod) {
long [][] W = new long [V.length][1];
for (int i : rep(V.length))
W[i][0] = V[i];
long [][] X = prod(A, W, mod);
long [] res = new long [X.length];
for (int i : rep(X.length))
res[i] = X[i][0];
return res;
}
long [][] sum (long [][] A, long [][] B, long mod) {
int M = A.length, K = A[0].length, N = B[0].length;
assert(K == B.length);
long [][] res = new long [M][N];
for (int i = 0; i < M; ++i)
for (int j = 0; j < N; ++j)
res[i][j] = mod(A[i][j] + B[i][j], mod);
return res;
}
long [][] prod (long [][] A, long [][] B, long mod) {
int M = A.length, K = A[0].length, N = B[0].length;
assert(K == B.length);
long [][] res = new long [M][N];
for (int i = 0; i < M; ++i)
for (int j = 0; j < N; ++j)
for (int k = 0; k < K; ++k)
res[i][j] = mod(res[i][j] + A[i][k] * B[k][j], mod);
return res;
}
long [][] pow (long [][] A, long e, long mod) {
long [][] res = id(A.length);
if (e > 0) {
int M = 1 + Long.numberOfTrailingZeros(Long.highestOneBit(e));
long [][][] P = new long[M][][]; P[0] = A;
for (int i : rep(1, M))
P[i] = prod(P[i-1], P[i-1], mod);
for (int i : rep(M))
if ((e & (1L << i)) != 0)
res = prod(res, P[i], mod);
}
return res;
}
long [][] id (int N) {
long [][] res = new long [N][N];
for (int i : rep(N))
res[i][i] = 1;
return res;
}
///////////////////////////////////////////////////////////////////////////
private static int [] rep(int N) { return rep(0, N); }
private static int [] rep(int S, int T) { if (T <= S) return new int [0]; int [] res = new int [T-S]; for (int i = S; i < T; ++i) res[i-S] = i; return res; }
private static long mod(long x, long mod) { return ((x % mod) + mod) % mod; }
////////////////////////////////////////////////////////////////////////////////////
private final static MyScanner sc = new MyScanner();
private static class MyScanner {
public String next() { newLine(); return line[index++]; }
public int nextInt() { return Integer.parseInt(next()); }
public long nextLong() { return Long.parseLong(next()); }
//////////////////////////////////////////////
private boolean eol() { return index == line.length; }
private String readLine() {
try {
return r.readLine();
} catch (Exception e) {
throw new Error (e);
}
}
private final java.io.BufferedReader r;
private MyScanner () { this(new java.io.BufferedReader(new java.io.InputStreamReader(System.in))); }
private MyScanner (java.io.BufferedReader r) {
try {
this.r = r;
while (!r.ready())
Thread.sleep(1);
start();
} catch (Exception e) {
throw new Error(e);
}
}
private String [] line;
private int index;
private void newLine() {
if (line == null || eol()) {
line = readLine().split(" ");
index = 0;
}
}
}
private static void print (Object o, Object... a) { printDelim(" ", o, a); }
private static void printDelim (String delim, Object o, Object... a) { pw.println(build(delim, o, a)); }
private static void exit (Object o, Object... a) { print(o, a); exit(); }
private static void exit() {
pw.close();
System.out.flush();
System.err.println("------------------");
System.err.println("Time: " + ((millis() - t) / 1000.0));
System.exit(0);
}
////////////////////////////////////////////////////////////////////////////////////
private static String build (String delim, Object o, Object... a) {
StringBuilder b = new StringBuilder();
append(b, o, delim);
for (Object p : a)
append(b, p, delim);
return b.substring(delim.length());
}
private static void append(StringBuilder b, Object o, String delim) {
if (o.getClass().isArray()) {
int L = java.lang.reflect.Array.getLength(o);
for (int i = 0; i < L; ++i)
append(b, java.lang.reflect.Array.get(o, i), delim);
} else if (o instanceof Iterable<?>)
for (Object p : (Iterable<?>)o)
append(b, p, delim);
else
b.append(delim).append(o);
}
////////////////////////////////////////////////////////////////////////////////////
private static void start() { t = millis(); }
private static java.io.PrintWriter pw = new java.io.PrintWriter(System.out, autoflush);
private static long t;
private static long millis() { return System.currentTimeMillis(); }
public static void main (String[] args) { new E(); exit(); }
}
|
This problem has nothing to do with Little Chris. It is about hill climbers instead (and Chris definitely isn't one).
There are n hills arranged on a line, each in the form of a vertical line segment with one endpoint on the ground. The hills are numbered with numbers from 1 to n from left to right. The i-th hill stands at position xi with its top at height yi. For every two hills a and b, if the top of hill a can be seen from the top of hill b, their tops are connected by a rope. Formally, the tops of two hills are connected if the segment connecting their top points does not intersect or touch any of the other hill segments. Using these ropes, the hill climbers can move from hill to hill.
There are m teams of climbers, each composed of exactly two members. The first and the second climbers of the i-th team are located at the top of the ai-th and bi-th hills, respectively. They want to meet together at the top of some hill. Now, each of two climbers move according to the following process:
1. if a climber is at the top of the hill where the other climber is already located or will come eventually, the former climber stays at this hill;
2. otherwise, the climber picks a hill to the right of his current hill that is reachable by a rope and is the rightmost possible, climbs this hill and continues the process (the climber can also climb a hill whose top is lower than the top of his current hill).
<image>
For each team of climbers, determine the number of the meeting hill for this pair!
Input
The first line of input contains a single integer n (1 ≤ n ≤ 105), the number of hills. The next n lines describe the hills. The i-th of them contains two space-separated integers xi, yi (1 ≤ xi ≤ 107; 1 ≤ yi ≤ 1011), the position and the height of the i-th hill. The hills are given in the ascending order of xi, i.e., xi < xj for i < j.
The next line of input contains a single integer m (1 ≤ m ≤ 105), the number of teams. The next m lines describe the teams. The i-th of them contains two space-separated integers ai, bi (1 ≤ ai, bi ≤ n), the numbers of the hills where the climbers of the i-th team are located. It is possible that ai = bi.
Output
In a single line output m space-separated integers, where the i-th integer is the number of the meeting hill for the members of the i-th team.
Examples
Input
6
1 4
2 1
3 2
4 3
6 4
7 4
3
3 1
5 6
2 3
Output
5 6 3
|
#include <bits/stdc++.h>
using namespace std;
struct point {
long long x, y;
point() {}
point(long long _x, long long _y) {
x = _x;
y = _y;
}
};
inline long long CCW(point a, point b, point c) {
long long a1 = b.x - a.x, b1 = b.y - a.y;
long long a2 = c.x - b.x, b2 = c.y - b.y;
return a1 * b2 - a2 * b1;
}
const int maxN = 1e5 + 5;
int n, m;
point p[maxN];
vector<int> head[maxN];
int st[maxN], top;
int parent[maxN][20], h[maxN];
void DFS(int u) {
for (int i = 0; i < (int)head[u].size(); ++i) {
int v = head[u][i];
parent[v][0] = u;
h[v] = h[u] + 1;
DFS(v);
}
}
void Init() {
m = (int)log2(n) + 1;
for (int j = 1; j <= m; ++j)
for (int i = 1; i <= n; ++i) parent[i][j] = parent[parent[i][j - 1]][j - 1];
}
void Jump(int &u, int x) {
for (int i = m; i >= 0; --i)
if (x >= (1 << i)) {
u = parent[u][i];
x -= (1 << i);
}
}
int LCA(int u, int v) {
if (h[u] > h[v])
Jump(u, h[u] - h[v]);
else
Jump(v, h[v] - h[u]);
if (u == v) return u;
for (int i = m; i >= 0; --i)
if (parent[u][i] != parent[v][i]) {
u = parent[u][i];
v = parent[v][i];
}
return parent[u][0];
}
int main() {
ios_base::sync_with_stdio(false);
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
long long x, y;
scanf("%I64d%I64d", &x, &y);
p[i] = point(x, y);
}
head[n].push_back(n - 1);
top = 2;
st[1] = n;
st[2] = n - 1;
for (int i = n - 2; i >= 1; --i) {
while (top >= 2 && CCW(p[st[top - 1]], p[st[top]], p[i]) < 0) --top;
head[st[top]].push_back(i);
st[++top] = i;
}
DFS(n);
Init();
int q = 0;
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
printf("%d ", LCA(u, v));
}
return 0;
}
|
Tachibana Kanade likes Mapo Tofu very much. One day, the canteen cooked all kinds of tofu to sell, but not all tofu is Mapo Tofu, only those spicy enough can be called Mapo Tofu.
Each piece of tofu in the canteen is given a m-based number, all numbers are in the range [l, r] (l and r being m-based numbers), and for every m-based integer in the range [l, r], there exists a piece of tofu with that number.
To judge what tofu is Mapo Tofu, Tachibana Kanade chose n m-based number strings, and assigned a value to each string. If a string appears in the number of a tofu, the value of the string will be added to the value of that tofu. If a string appears multiple times, then the value is also added that many times. Initially the value of each tofu is zero.
Tachibana Kanade considers tofu with values no more than k to be Mapo Tofu. So now Tachibana Kanade wants to know, how many pieces of tofu are Mapo Tofu?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 200; 2 ≤ m ≤ 20; 1 ≤ k ≤ 500). Where n denotes the number of strings, m denotes the base used, and k denotes the limit of the value for Mapo Tofu.
The second line represents the number l. The first integer in the line is len (1 ≤ len ≤ 200), describing the length (number of digits in base m) of l. Then follow len integers a1, a2, ..., alen (0 ≤ ai < m; a1 > 0) separated by spaces, representing the digits of l, with a1 being the highest digit and alen being the lowest digit.
The third line represents the number r in the same format as l. It is guaranteed that 1 ≤ l ≤ r.
Then follow n lines, each line describing a number string. The i-th line contains the i-th number string and vi — the value of the i-th string (1 ≤ vi ≤ 200). All number strings are described in almost the same format as l, the only difference is number strings may contain necessary leading zeros (see the first example). The sum of the lengths of all number strings does not exceed 200.
Output
Output the number of pieces of Mapo Tofu modulo 1000000007 (109 + 7). The answer should be a decimal integer.
Examples
Input
2 10 1
1 1
3 1 0 0
1 1 1
1 0 1
Output
97
Input
2 10 12
2 5 9
6 6 3 5 4 9 7
2 0 6 1
3 6 7 2 1
Output
635439
Input
4 2 6
6 1 0 1 1 1 0
6 1 1 0 1 0 0
1 1 2
3 0 1 0 5
4 0 1 1 0 4
3 1 0 1 2
Output
2
Note
In the first sample, 10, 11 and 100 are the only three decimal numbers in [1, 100] with a value greater than 1. Here the value of 1 is 1 but not 2, since numbers cannot contain leading zeros and thus cannot be written as "01".
In the second sample, no numbers in the given interval have a value greater than 12.
In the third sample, 110000 and 110001 are the only two binary numbers in the given interval with a value no greater than 6.
|
#include <bits/stdc++.h>
using namespace std;
template <typename F, typename U>
ostream& operator<<(ostream& os, const pair<F, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename F>
ostream& operator<<(ostream& os, const vector<F>& v) {
os << "[";
for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); ++i) {
if (i != v.begin()) os << ", ";
os << *i;
}
os << "]";
return os;
}
int m;
const int MOD = 1000000007;
void add(int& a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
void read_number(vector<int>& A) {
int el;
scanf("%d", &el);
A.clear();
A.resize(el);
for (int i = 0; i < (int)(el); ++i) scanf("%d", &A[i]);
}
int cnt_nodes = 0;
struct Node;
struct Node {
int index, cost;
vector<Node*> next;
Node* fail;
Node() : index(cnt_nodes++), cost(0), next(m, (Node*)NULL), fail(NULL) {}
};
Node* ground;
Node* root;
void add_string(const vector<int>& A, int cost) {
Node* x = root;
for (int i = 0; i < (int)(((int)((A).size()))); ++i) {
if (x->next[A[i]] == NULL) x->next[A[i]] = new Node();
x = x->next[A[i]];
}
x->cost += cost;
}
vector<vector<int> > F;
vector<vector<int> > C;
void compute_fail_links() {
F.clear();
F.resize(cnt_nodes, vector<int>(m, -1));
C.clear();
C.resize(cnt_nodes, vector<int>(m, 0));
root->fail = ground;
queue<Node*> Q;
Q.push(root);
while (!Q.empty()) {
Node* x = Q.front();
Q.pop();
for (int i = 0; i < (int)(m); ++i) {
if (x->next[i] != NULL) {
Node* y = x->fail;
while (y->next[i] == NULL) y = y->fail;
x->next[i]->fail = y->next[i];
x->next[i]->cost += y->next[i]->cost;
Q.push(x->next[i]);
}
Node* y = x;
while (y->next[i] == NULL) y = y->fail;
F[x->index][i] = y->next[i]->index;
C[x->index][i] = y->next[i]->cost;
}
}
}
int solve(const vector<int>& V, int k) {
vector<vector<int> > D_lt(cnt_nodes, vector<int>(k + 1, 0));
vector<vector<int> > D_eq(cnt_nodes, vector<int>(k + 1, 0));
vector<vector<int> > D_gt(cnt_nodes, vector<int>(k + 1, 0));
D_eq[root->index][0] = 1;
int res = 0;
for (int vi = 0; vi < (int)(((int)((V).size()))); ++vi) {
vector<vector<int> > T_lt(cnt_nodes, vector<int>(k + 1, 0));
vector<vector<int> > T_eq(cnt_nodes, vector<int>(k + 1, 0));
vector<vector<int> > T_gt(cnt_nodes, vector<int>(k + 1, 0));
for (int i = (int)(1); i <= (int)(cnt_nodes - 1); ++i)
for (int s = (int)(0); s <= (int)(k); ++s)
for (int j = 0; j < (int)(m); ++j) {
if (vi == 0 && j == 0) continue;
int ni = F[i][j];
int ns = s + C[i][j];
if (ns > k) continue;
add(T_lt[ni][ns], D_lt[i][s]);
if (j < V[vi]) {
add(T_lt[ni][ns], D_eq[i][s]);
} else if (j == V[vi]) {
add(T_eq[ni][ns], D_eq[i][s]);
} else {
add(T_gt[ni][ns], D_eq[i][s]);
}
add(T_gt[ni][ns], D_gt[i][s]);
}
for (int i = (int)(1); i <= (int)(cnt_nodes - 1); ++i)
for (int s = (int)(0); s <= (int)(k); ++s) {
add(res, T_lt[i][s]);
add(res, T_eq[i][s]);
if (vi < ((int)((V).size())) - 1) add(res, T_gt[i][s]);
}
D_lt.swap(T_lt);
D_eq.swap(T_eq);
D_gt.swap(T_gt);
}
return res;
}
int main() {
int n, k;
scanf("%d%d%d", &n, &m, &k);
vector<int> U, V;
read_number(U);
read_number(V);
for (int i = (int)(((int)((U).size())) - 1); i >= (int)(0); --i)
if (U[i] > 0) {
--U[i];
break;
} else {
U[i] = m - 1;
}
ground = new Node();
root = new Node();
for (int i = 0; i < (int)(m); ++i) ground->next[i] = root;
for (int i = 0; i < (int)(n); ++i) {
vector<int> S;
read_number(S);
int cost;
scanf("%d", &cost);
add_string(S, cost);
}
compute_fail_links();
int res = solve(V, k);
if (!U.empty()) res = (res - solve(U, k) + MOD) % MOD;
printf("%d\n", res);
}
|
Fedya studies in a gymnasium. Fedya's maths hometask is to calculate the following expression:
(1n + 2n + 3n + 4n) mod 5
for given value of n. Fedya managed to complete the task. Can you? Note that given number n can be extremely large (e.g. it can exceed any integer type of your programming language).
Input
The single line contains a single integer n (0 ≤ n ≤ 10105). The number doesn't contain any leading zeroes.
Output
Print the value of the expression without leading zeros.
Examples
Input
4
Output
4
Input
124356983594583453458888889
Output
0
Note
Operation x mod y means taking remainder after division x by y.
Note to the first sample:
<image>
|
n=int(input())
if n==0:
answer=4
else:
a=1
if n%4==0:
a+=6+1
elif n%4==1:
a+=2+3
elif n%4==2:
a+=4+9
else:
a+=8+7
if n%2==0:
a+=6
else:
a+=4
answer=a%5
print(answer)
|
A wavy number is such positive integer that for any digit of its decimal representation except for the first one and the last one following condition holds: the digit is either strictly larger than both its adjacent digits or strictly less than both its adjacent digits. For example, numbers 35270, 102, 747, 20 and 3 are wavy and numbers 123, 1000 and 2212 are not.
The task is to find the k-th smallest wavy number r that is divisible by n for the given integer values n and k.
You are to write a program that will find the value of r if it doesn't exceed 1014.
Input
The only line of input contains two integers n and k, separated by a single space (1 ≤ n, k ≤ 1014).
Output
Your task is to output the only integer r — the answer to the given problem. If such number does not exist or it is larger than 1014, then print "-1" (minus one without the quotes) instead.
Examples
Input
123 4
Output
1845
Input
100 1
Output
-1
Input
97461 457
Output
1805270103
Note
The values of the first four wavy numbers that are divisible by n for the first sample are: 492, 615, 738 and 1845.
|
#include <bits/stdc++.h>
using namespace std;
const int maxs = 1000050, maxss = maxs * 10, mm = 1e7, mm1 = 1e6, mm2 = 1e5;
long long n, K, ans = -1;
int num1[maxs], s1 = 0, num2[maxs], s2 = 0;
int hs = 0, he[maxss], ne[maxs], cnt[maxs];
long long st[maxs];
long long chg(int x, int y, long long z) { return (z * 10 + x) * 10 + y; }
void push(long long sta) {
int i, st0 = sta % maxss;
for (i = he[st0]; i; i = ne[i])
if (st[i] == sta) {
cnt[i]++;
return;
}
ne[++hs] = he[st0], he[st0] = hs, st[hs] = sta, cnt[hs]++;
}
int query(long long sta) {
int i, st0 = sta % maxss;
for (i = he[st0]; i; i = ne[i])
if (st[i] == sta) return cnt[i];
return 0;
}
void dfs(int x, int d) {
if (d >= 7) {
if (x) num1[s1++] = x;
if (x / mm1 || (x / 100000 && x / 100000 > x / 10000 % 10)) num2[s2++] = x;
return;
}
int i;
if (x < 10) {
for (i = 0; i <= 9; i++)
if (!x || i != x) dfs(x * 10 + i, d + 1);
} else if (x / 10 % 10 > x % 10)
for (i = x % 10 + 1; i <= 9; i++) dfs(x * 10 + i, d + 1);
else if (x / 10 % 10 < x % 10)
for (i = 0; i < x % 10; i++) dfs(x * 10 + i, d + 1);
}
int main() {
int i, j, k, i2;
bool z = 0;
scanf("%I64d%I64d", &n, &K);
dfs(0, 0);
for (i = 0; i < s2; i++)
push(chg(num2[i] / mm1, num2[i] / mm2 % 10, num2[i] % n));
for (i = 0; i < s1; i++)
if (!(num1[i] % n) && !--K) {
ans = num1[i];
break;
}
if (K) {
for (i = 0; i < s1; i++) {
long long rem = (n - (long long)num1[i] * mm % n) % n;
int tt = num1[i] % 10,
t = (!(num1[i] / 10) ? 0 : (num1[i] / 10 % 10 > tt ? 1 : -1));
for (j = 0; j < 10; j++) {
for (k = 0; k < 10; k++)
if ((t > 0 && tt < j && j > k) || (t < 0 && tt > j && j < k) ||
(!t && tt != j && j != k && (tt > j) != (j > k))) {
int ts = query(chg(j, k, rem));
if (K <= ts) {
z = 1;
break;
}
K -= ts;
}
if (z) break;
}
if (z) {
for (i2 = 0; i2 < s2; i2++)
if (num2[i2] / mm1 == j && num2[i2] / mm2 % 10 == k &&
num2[i2] % n == rem && !(--K)) {
ans = (long long)num1[i] * mm + num2[i2];
break;
}
break;
}
}
}
printf("%I64d\n", ans);
return 0;
}
|
New Year is coming in Tree Island! In this island, as the name implies, there are n cities connected by n - 1 roads, and for any two distinct cities there always exists exactly one path between them. For every person in Tree Island, it takes exactly one minute to pass by exactly one road.
There is a weird New Year tradition for runnners in Tree Island, which is called "extreme run". This tradition can be done as follows.
A runner chooses two distinct cities a and b. For simplicity, let's denote the shortest path from city a to city b as p1, p2, ..., pl (here, p1 = a and pl = b holds). Then following happens:
1. The runner starts at city a.
2. The runner runs from city a to b, following the shortest path from city a to city b.
3. When the runner arrives at city b, he turns his direction immediately (it takes no time), and runs towards city a, following the shortest path from city b to city a.
4. When the runner arrives at city a, he turns his direction immediately (it takes no time), and runs towards city b, following the shortest path from city a to city b.
5. Repeat step 3 and step 4 forever.
In short, the course of the runner can be denoted as: <image> <image>
Two runners JH and JY decided to run "extremely" in order to celebrate the New Year. JH has chosen two cities u and v, and JY has chosen two cities x and y. They decided to start running at the same moment, and run until they meet at the same city for the first time. Meeting on a road doesn't matter for them. Before running, they want to know the amount of time they will run.
It is too hard for JH and JY to calculate this, so they ask you for help.
Input
The first line contains a single positive integer n (5 ≤ n ≤ 2 × 105) — the number of cities in Tree Island.
Next n - 1 lines describe the roads of Tree Island. The i-th line (1 ≤ i ≤ n - 1) of them contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) — the vertices connected by a single road of the tree.
The next line contains an integer t (1 ≤ t ≤ 2 × 105) — the number of test cases.
Next t lines describes the test cases. The j-th line (1 ≤ j ≤ t) of them contains four space-separated integers uj, vj, xj, yj (1 ≤ uj, vj, xj, yj ≤ n, uj ≠ vj, xj ≠ yj). It means that in this test case, JH has chosen two cities uj and vj, JY has chosen two cities xj and yj. JH starts running at city uj, and JY starts running at city xj.
Output
For each test case, print an integer describing the amount of time they should run in minutes. If they have to run for an infinitely long time (in other words, if they never meet at the same city), print -1 instead. If they meet at the beginning of their run, print 0.
Examples
Input
7
1 3
3 6
7 4
3 7
5 4
7 2
4
6 5 5 3
3 5 4 6
1 5 1 3
1 5 3 1
Output
2
1
0
-1
Note
The example looks like:
<image>
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long y, nex;
} a[2 * 210000];
struct node1 {
long long dep, par[20];
} t[210000];
long long fir[210000], len, n, m, z;
long long inf = 1ll << 60;
bool bo;
void ins(long long x, long long y) {
a[++len].y = y;
a[len].nex = fir[x];
fir[x] = len;
}
void dfs(long long x, long long fa) {
t[x].dep = t[fa].dep + 1;
t[x].par[0] = fa;
for (long long i = 1; i <= 18; i++)
t[x].par[i] = t[t[x].par[i - 1]].par[i - 1];
for (long long k = fir[x]; k; k = a[k].nex) {
long long y = a[k].y;
if (y == fa) continue;
dfs(y, x);
}
}
long long lca(long long x, long long y) {
if (t[x].dep < t[y].dep) swap(x, y);
for (long long i = 18; i >= 0; i--)
if (t[t[x].par[i]].dep >= t[y].dep) x = t[x].par[i];
if (x == y) return x;
for (long long i = 18; i >= 0; i--)
if (t[x].par[i] != t[y].par[i]) x = t[x].par[i], y = t[y].par[i];
return t[x].par[0];
}
long long lower(long long x, long long y) {
if (t[x].dep > t[y].dep) return x;
return y;
}
long long dis(long long x, long long y) {
long long u = lca(x, y);
return t[x].dep + t[y].dep - 2 * t[u].dep;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long t = a / b, g, xx, yy;
g = exgcd(b, a % b, xx, yy);
x = yy;
y = xx - t * yy;
return g;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long same(long long t1, long long t2, long long f1, long long f2) {
long long t = ((t2 - t1) % f2 + f2) % f2;
long long p, q, g, m;
g = exgcd(f1, f2, p, q);
if (t % g) return inf;
p *= t / g;
q *= t / g;
m = f2 / g;
p = (p % m + m) % m;
return p * f1 + t1;
}
long long G(long long M, long long D, long long L, long long R) {
long long t = L / D;
if (t * D < L) t++;
if (t * D <= R) return t;
if (2 * D > M) return G(M, M - D, M - R, M - L);
long long k = G(D, ((-M % D) + D) % D, L % D, R % D);
L += M * k;
R += M * k;
t = L / D;
if (t * D < L) t++;
return t;
}
long long make(long long M, long long D, long long L, long long R) {
long long g = gcd(M, D);
if ((L - 1) / g >= R / g) return inf;
return G(M, D, L, R);
}
long long diff(long long t1, long long t2, long long f1, long long f2,
long long d) {
long long l = t2 - t1 - d, r = t2 - t1 + d;
l = (l % f2 + f2) % f2;
r = (r % f2 + f2) % f2;
if (l % 2) return inf;
if (l > r || l == 0) return t1 + r / 2;
if (f2 == d * 2) return t1 + r / 2;
long long p = make(f2, f1 % f2, l, r), q;
if (p == inf) return inf;
return p * f1 + t1 + d - (p * f1 % f2 - l) / 2;
}
long long solve() {
long long x, y, u, v, a, b, p1, p2, p3, p4, p5, p6, p, d, t1, t2, t3, t4, f1,
f2, d1, d2;
z++;
scanf("%lld%lld%lld%lld", &x, &y, &u, &v);
if (bo && z == 143) printf("%lld %lld %lld %lld\n", x, y, u, v);
p1 = lca(x, y);
p2 = lca(u, v);
p3 = lca(x, u);
p4 = lca(x, v);
p5 = lca(y, u);
p6 = lca(y, v);
p = lower(p1, p2);
a = lower(p3, p4);
b = lower(p5, p6);
if (t[p].dep > t[a].dep && t[p].dep > t[b].dep) return -1;
if (t[p].dep > t[a].dep)
a = p;
else if (t[p].dep > t[b].dep)
b = p;
d = dis(a, b);
f1 = 2 * dis(x, y);
f2 = 2 * dis(u, v);
d1 = dis(x, a);
d2 = dis(x, b);
if (d1 < d2)
t1 = d1, t2 = f1 - d2;
else
t1 = f1 - d1, t2 = d2;
d1 = dis(u, a);
d2 = dis(u, b);
if (d1 < d2)
t3 = d1, t4 = f2 - d2;
else
t3 = f2 - d1, t4 = d2;
long long res = inf;
res = min(same(t1, t3, f1, f2), res);
res = min(same(t2, t4, f1, f2), res);
res = min(diff(t1, t4, f1, f2, d), res);
res = min(diff(t2, t3, f1, f2, d), res);
if (res == inf) res = -1;
return res;
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i < n; i++) {
long long x, y;
scanf("%lld%lld", &x, &y);
ins(x, y);
ins(y, x);
}
dfs(1, 0);
scanf("%lld", &m);
while (m--) {
long long ans = solve();
if (bo == 0) printf("%lld\n", ans);
}
return 0;
}
|
Optimizing the amount of data transmitted via a network is an important and interesting part of developing any network application.
<image>
In one secret game developed deep in the ZeptoLab company, the game universe consists of n levels, located in a circle. You can get from level i to levels i - 1 and i + 1, also you can get from level 1 to level n and vice versa. The map of the i-th level description size is ai bytes.
In order to reduce the transmitted traffic, the game gets levels as follows. All the levels on the server are divided into m groups and each time a player finds himself on one of the levels of a certain group for the first time, the server sends all levels of the group to the game client as a single packet. Thus, when a player travels inside the levels of a single group, the application doesn't need any new information. Due to the technical limitations the packet can contain an arbitrary number of levels but their total size mustn't exceed b bytes, where b is some positive integer constant.
Usual situation is that players finish levels one by one, that's why a decision was made to split n levels into m groups so that each group was a continuous segment containing multiple neighboring levels (also, the group can have two adjacent levels, n and 1). Specifically, if the descriptions of all levels have the total weight of at most b bytes, then they can all be united into one group to be sent in a single packet.
Determine, what minimum number of groups do you need to make in order to organize the levels of the game observing the conditions above?
As developing a game is a long process and technology never stagnates, it is yet impossible to predict exactly what value will take constant value b limiting the packet size when the game is out. That's why the developers ask you to find the answer for multiple values of b.
Input
The first line contains two integers n, q (2 ≤ n ≤ 106, 1 ≤ q ≤ 50) — the number of levels in the game universe and the number of distinct values of b that you need to process.
The second line contains n integers ai (1 ≤ ai ≤ 109) — the sizes of the levels in bytes.
The next q lines contain integers bj (<image>), determining the values of constant b, for which you need to determine the answer.
Output
For each value of kj from the input print on a single line integer mj (1 ≤ mj ≤ n), determining the minimum number of groups to divide game levels into for transmission via network observing the given conditions.
Examples
Input
6 3
2 4 2 1 3 2
7
4
6
Output
2
4
3
Note
In the test from the statement you can do in the following manner.
* at b = 7 you can divide into two segments: 2|421|32 (note that one of the segments contains the fifth, sixth and first levels);
* at b = 4 you can divide into four segments: 2|4|21|3|2;
* at b = 6 you can divide into three segments: 24|21|32|.
|
import java.io.*;
import java.util.*;
public class E {
void solve() throws IOException {
int n = nextInt();
int q = nextInt();
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
long[] sum = new long[n + 1];
for (int i = n - 1; i >= 0; i--) {
sum[i] = a[i] + sum[i + 1];
}
for (int it = 0; it < q; it++) {
int[] res = new int[n];
long[] last = new long[n];
long b = nextLong();
int lastIndex = n;
for (int i = n - 1; i >= 0; i--) {
while (sum[i] - sum[lastIndex] > b) {
lastIndex--;
}
if (lastIndex == n) {
res[i] = 1;
last[i] = sum[i];
} else {
res[i] = res[lastIndex]+1;
last[i] = last[lastIndex];
}
}
int result = Integer.MAX_VALUE / 2;
long summ = 0;
for (int i = 0; i < n; i++) {
summ += a[i];
if (summ > b) {
break;
}
if (i == n - 1) {
result = 1;
break;
}
if (summ + last[i + 1] <= b) {
result = Math.min(result, res[i + 1]);
} else {
result = Math.min(result, res[i + 1]+1);
}
}
out.println(result);
}
}
void run() throws IOException {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
out.close();
}
public static void main(String[] args) throws IOException {
new E().run();
}
BufferedReader in;
PrintWriter out;
StringTokenizer st;
String next() throws IOException {
while (st == null || !st.hasMoreTokens()) {
String temp = in.readLine();
if (temp == null) {
return null;
}
st = new StringTokenizer(temp);
}
return st.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(next());
}
double nextDouble() throws IOException {
return Double.parseDouble(next());
}
long nextLong() throws IOException {
return Long.parseLong(next());
}
}
|
Vanya has a table consisting of 100 rows, each row contains 100 cells. The rows are numbered by integers from 1 to 100 from bottom to top, the columns are numbered from 1 to 100 from left to right.
In this table, Vanya chose n rectangles with sides that go along borders of squares (some rectangles probably occur multiple times). After that for each cell of the table he counted the number of rectangles it belongs to and wrote this number into it. Now he wants to find the sum of values in all cells of the table and as the table is too large, he asks you to help him find the result.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of rectangles.
Each of the following n lines contains four integers x1, y1, x2, y2 (1 ≤ x1 ≤ x2 ≤ 100, 1 ≤ y1 ≤ y2 ≤ 100), where x1 and y1 are the number of the column and row of the lower left cell and x2 and y2 are the number of the column and row of the upper right cell of a rectangle.
Output
In a single line print the sum of all values in the cells of the table.
Examples
Input
2
1 1 2 3
2 2 3 3
Output
10
Input
2
1 1 3 3
1 1 3 3
Output
18
Note
Note to the first sample test:
Values of the table in the first three rows and columns will be as follows:
121
121
110
So, the sum of values will be equal to 10.
Note to the second sample test:
Values of the table in the first three rows and columns will be as follows:
222
222
222
So, the sum of values will be equal to 18.
|
#include <bits/stdc++.h>
using namespace std;
long long V[101][101];
int main() {
long long a, b, c, d, T;
cin >> T;
long long sum = 0;
while (T--) {
cin >> a >> b >> c >> d;
for (int i = a; i <= c; i++) {
for (int j = b; j <= d; j++) {
sum++;
}
}
}
cout << sum;
}
|
You are a lover of bacteria. You want to raise some bacteria in a box.
Initially, the box is empty. Each morning, you can put any number of bacteria into the box. And each night, every bacterium in the box will split into two bacteria. You hope to see exactly x bacteria in the box at some moment.
What is the minimum number of bacteria you need to put into the box across those days?
Input
The only line containing one integer x (1 ≤ x ≤ 109).
Output
The only line containing one integer: the answer.
Examples
Input
5
Output
2
Input
8
Output
1
Note
For the first sample, we can add one bacterium in the box in the first day morning and at the third morning there will be 4 bacteria in the box. Now we put one more resulting 5 in the box. We added 2 bacteria in the process so the answer is 2.
For the second sample, we can put one in the first morning and in the 4-th morning there will be 8 in the box. So the answer is 1.
|
from __future__ import division
from collections import Counter as ctr
from math import ceil, log, factorial
# reads a line of input and converts into a list of ints
# 1 1 3 => [1, 1, 3]
def rl():
return [int(i) for i in raw_input().split()]
# reads n lines of input (if n defined) and returns a list of strings
# where each element is a line in the input
# abc
# abcdef
# => ['abc', 'abcdef']
# if n not defined, read first line to get number of lines
# 2
# abc
# abcdef
# => ['abc', 'abcdef']
def rm(n=None):
if n is None:
n = input()
return [raw_input() for i in range(n)]
# same as rm, except converts each line to a list of ints like rl
def rlm(n=None):
if n is None:
n = input()
return [rl() for i in range(n)]
def yn(b):
if b:
print "YES"
else:
print "NO"
print bin(input()).count('1')
|
Everyone knows that long ago on the territory of present-day Berland there lived Bindian tribes. Their capital was surrounded by n hills, forming a circle. On each hill there was a watchman, who watched the neighbourhood day and night.
In case of any danger the watchman could make a fire on the hill. One watchman could see the signal of another watchman, if on the circle arc connecting the two hills there was no hill higher than any of the two. As for any two hills there are two different circle arcs connecting them, the signal was seen if the above mentioned condition was satisfied on at least one of the arcs. For example, for any two neighbouring watchmen it is true that the signal of one will be seen by the other.
An important characteristics of this watch system was the amount of pairs of watchmen able to see each other's signals. You are to find this amount by the given heights of the hills.
Input
The first line of the input data contains an integer number n (3 ≤ n ≤ 106), n — the amount of hills around the capital. The second line contains n numbers — heights of the hills in clockwise order. All height numbers are integer and lie between 1 and 109.
Output
Print the required amount of pairs.
Examples
Input
5
1 2 4 5 3
Output
7
|
#include <bits/stdc++.h>
using namespace std;
void file() {
freopen("std.in", "r", stdin);
freopen("wa.out", "w", stdout);
}
const long long N = 1e6 + 10, M = 2e6 + 10, inf = 1e9;
inline long long read() {
bool sym = 0;
long long res = 0;
char ch = getchar();
while (!isdigit(ch)) sym |= (ch == '-'), ch = getchar();
while (isdigit(ch)) res = (res << 3) + (res << 1) + (ch ^ 48), ch = getchar();
return sym ? -res : res;
}
long long n, m, t[N], h[N], s[N], cnt[N], top;
signed main() {
n = read();
long long mx = 0, pos;
for (long long i = 1; i <= n; i++) {
t[i] = read();
if (t[i] > mx) {
pos = i;
mx = t[i];
}
}
long long p = 0, ans = n - 1;
for (long long i = pos + 1; i <= n; i++) h[++p] = t[i];
for (long long i = 1; i < pos; i++) h[++p] = t[i];
top = 0;
for (long long i = 1; i <= p; i++) {
while (s[top] < h[i] && top) ans += cnt[top--];
if (s[top] != h[i]) s[++top] = h[i], cnt[top] = 0;
ans += cnt[top]++;
}
while (top >= 2) ans += cnt[top--];
cout << ans;
return 0;
}
|
You are given array a with n integers and m queries. The i-th query is given with three integers li, ri, xi.
For the i-th query find any position pi (li ≤ pi ≤ ri) so that api ≠ xi.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2·105) — the number of elements in a and the number of queries.
The second line contains n integers ai (1 ≤ ai ≤ 106) — the elements of the array a.
Each of the next m lines contains three integers li, ri, xi (1 ≤ li ≤ ri ≤ n, 1 ≤ xi ≤ 106) — the parameters of the i-th query.
Output
Print m lines. On the i-th line print integer pi — the position of any number not equal to xi in segment [li, ri] or the value - 1 if there is no such number.
Examples
Input
6 4
1 2 1 1 3 5
1 4 1
2 6 2
3 4 1
3 4 2
Output
2
6
-1
4
|
#include <bits/stdc++.h>
using namespace std;
int N, M, a[200010], dp[200010];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M;
int i, l, r, x;
for (i = 1; i <= N; i++) cin >> a[i];
for (i = N; i > 0; i--) {
dp[i] = i;
if (a[i + 1] == a[i]) dp[i] = dp[i + 1];
}
while (M--) {
cin >> l >> r >> x;
if (a[l] != x)
cout << l << "\n";
else {
if (dp[l] >= r)
cout << -1 << "\n";
else
cout << dp[l] + 1 << "\n";
}
}
return 0;
}
|
There are n bears in the inn and p places to sleep. Bears will party together for some number of nights (and days).
Bears love drinking juice. They don't like wine but they can't distinguish it from juice by taste or smell.
A bear doesn't sleep unless he drinks wine. A bear must go to sleep a few hours after drinking a wine. He will wake up many days after the party is over.
Radewoosh is the owner of the inn. He wants to put some number of barrels in front of bears. One barrel will contain wine and all other ones will contain juice. Radewoosh will challenge bears to find a barrel with wine.
Each night, the following happens in this exact order:
1. Each bear must choose a (maybe empty) set of barrels. The same barrel may be chosen by many bears.
2. Each bear drinks a glass from each barrel he chose.
3. All bears who drink wine go to sleep (exactly those bears who chose a barrel with wine). They will wake up many days after the party is over. If there are not enough places to sleep then bears lose immediately.
At the end, if it's sure where wine is and there is at least one awake bear then bears win (unless they have lost before because of the number of places to sleep).
Radewoosh wants to allow bears to win. He considers q scenarios. In the i-th scenario the party will last for i nights. Then, let Ri denote the maximum number of barrels for which bears surely win if they behave optimally. Let's define <image>. Your task is to find <image>, where <image> denotes the exclusive or (also denoted as XOR).
Note that the same barrel may be chosen by many bears and all of them will go to sleep at once.
Input
The only line of the input contains three integers n, p and q (1 ≤ n ≤ 109, 1 ≤ p ≤ 130, 1 ≤ q ≤ 2 000 000) — the number of bears, the number of places to sleep and the number of scenarios, respectively.
Output
Print one integer, equal to <image>.
Examples
Input
5 1 3
Output
32
Input
1 100 4
Output
4
Input
3 2 1
Output
7
Input
100 100 100
Output
381863924
Note
In the first sample, there are 5 bears and only 1 place to sleep. We have R1 = 6, R2 = 11, R3 = 16 so the answer is <image>. Let's analyze the optimal strategy for scenario with 2 days. There are R2 = 11 barrels and 10 of them contain juice.
* In the first night, the i-th bear chooses a barrel i only.
* If one of the first 5 barrels contains wine then one bear goes to sleep. Then, bears win because they know where wine is and there is at least one awake bear.
* But let's say none of the first 5 barrels contains wine. In the second night, the i-th bear chooses a barrel 5 + i.
* If one of barrels 6 – 10 contains wine then one bear goes to sleep. And again, bears win in such a situation.
* If nobody went to sleep then wine is in a barrel 11.
In the second sample, there is only one bear. He should choose an empty set of barrels in each night. Otherwise, he would maybe get wine and bears would lose (because there must be at least one awake bear). So, for any number of days we have Ri = 1. The answer is <image>.
|
#include <bits/stdc++.h>
using namespace std;
int n, q, p;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
inline unsigned int C(int n, int r) {
vector<int> tmp;
for (int i = 1; i <= r; i++) tmp.push_back(n - i + 1);
for (int i = 1; i <= r; i++) {
int zjk = i;
for (auto &t : tmp)
if (t != 1) {
int g = gcd(zjk, t);
zjk /= g, t /= g;
}
}
unsigned int res = 1;
for (auto t : tmp) res *= t;
return res;
}
inline unsigned int Pow(unsigned int x, int y) {
unsigned int res = 1;
for (; y; y >>= 1, x *= x)
if (y & 1) res *= x;
return res;
}
unsigned int t[150];
int main() {
scanf("%d%d%d", &n, &p, &q), p = min(p, n - 1);
for (int i = 0; i <= p; i++) t[i] = C(n, i);
unsigned int res = 0;
for (int i = 1; i <= q; i++) {
unsigned int tmp = 0;
for (int j = 0; j <= p; j++) tmp += t[j] * Pow(i, j);
res ^= tmp * i;
}
printf("%u\n", res);
return 0;
}
|
Recently Polycarp started to develop a text editor that works only with correct bracket sequences (abbreviated as CBS).
Note that a bracket sequence is correct if it is possible to get a correct mathematical expression by adding "+"-s and "1"-s to it. For example, sequences "(())()", "()" and "(()(()))" are correct, while ")(", "(()" and "(()))(" are not. Each bracket in CBS has a pair. For example, in "(()(()))":
* 1st bracket is paired with 8th,
* 2d bracket is paired with 3d,
* 3d bracket is paired with 2d,
* 4th bracket is paired with 7th,
* 5th bracket is paired with 6th,
* 6th bracket is paired with 5th,
* 7th bracket is paired with 4th,
* 8th bracket is paired with 1st.
Polycarp's editor currently supports only three operations during the use of CBS. The cursor in the editor takes the whole position of one of the brackets (not the position between the brackets!). There are three operations being supported:
* «L» — move the cursor one position to the left,
* «R» — move the cursor one position to the right,
* «D» — delete the bracket in which the cursor is located, delete the bracket it's paired to and all brackets between them (that is, delete a substring between the bracket in which the cursor is located and the one it's paired to).
After the operation "D" the cursor moves to the nearest bracket to the right (of course, among the non-deleted). If there is no such bracket (that is, the suffix of the CBS was deleted), then the cursor moves to the nearest bracket to the left (of course, among the non-deleted).
There are pictures illustrated several usages of operation "D" below.
<image>
All incorrect operations (shift cursor over the end of CBS, delete the whole CBS, etc.) are not supported by Polycarp's editor.
Polycarp is very proud of his development, can you implement the functionality of his editor?
Input
The first line contains three positive integers n, m and p (2 ≤ n ≤ 500 000, 1 ≤ m ≤ 500 000, 1 ≤ p ≤ n) — the number of brackets in the correct bracket sequence, the number of operations and the initial position of cursor. Positions in the sequence are numbered from left to right, starting from one. It is guaranteed that n is even.
It is followed by the string of n characters "(" and ")" forming the correct bracket sequence.
Then follow a string of m characters "L", "R" and "D" — a sequence of the operations. Operations are carried out one by one from the first to the last. It is guaranteed that the given operations never move the cursor outside the bracket sequence, as well as the fact that after all operations a bracket sequence will be non-empty.
Output
Print the correct bracket sequence, obtained as a result of applying all operations to the initial sequence.
Examples
Input
8 4 5
(())()()
RDLD
Output
()
Input
12 5 3
((()())(()))
RRDLD
Output
(()(()))
Input
8 8 8
(())()()
LLLLLLDD
Output
()()
Note
In the first sample the cursor is initially at position 5. Consider actions of the editor:
1. command "R" — the cursor moves to the position 6 on the right;
2. command "D" — the deletion of brackets from the position 5 to the position 6. After that CBS takes the form (())(), the cursor is at the position 5;
3. command "L" — the cursor moves to the position 4 on the left;
4. command "D" — the deletion of brackets from the position 1 to the position 4. After that CBS takes the form (), the cursor is at the position 1.
Thus, the answer is equal to ().
|
#include <bits/stdc++.h>
using namespace std;
int pre[500500], nex[500500], p[500500];
stack<int> s;
void connect(int x, int y) {
nex[x] = y;
pre[y] = x;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, c, i;
string b, o;
cin >> n >> m >> c >> b;
c--;
s.push(0);
connect(n, 0);
for (i = 1; i < n; i++) {
connect(i - 1, i);
if (b[i] == '(')
s.push(i);
else {
p[i] = s.top();
p[p[i]] = i;
s.pop();
}
}
connect(n - 1, n);
cin >> o;
for (i = 0; i < m; i++) {
if (o[i] == 'L')
c = pre[c];
else if (o[i] == 'R')
c = nex[c];
else if (p[c] < c) {
connect(pre[p[c]], nex[c]);
if (nex[c] == n)
c = pre[p[c]];
else
c = nex[c];
} else {
connect(pre[c], nex[p[c]]);
if (nex[p[c]] == n)
c = pre[c];
else
c = nex[p[c]];
}
}
i = nex[n];
while (i < n) {
cout << b[i];
i = nex[i];
}
}
|
Barney lives in country USC (United States of Charzeh). USC has n cities numbered from 1 through n and n - 1 roads between them. Cities and roads of USC form a rooted tree (Barney's not sure why it is rooted). Root of the tree is the city number 1. Thus if one will start his journey from city 1, he can visit any city he wants by following roads.
<image>
Some girl has stolen Barney's heart, and Barney wants to find her. He starts looking for in the root of the tree and (since he is Barney Stinson not a random guy), he uses a random DFS to search in the cities. A pseudo code of this algorithm is as follows:
let starting_time be an array of length n
current_time = 0
dfs(v):
current_time = current_time + 1
starting_time[v] = current_time
shuffle children[v] randomly (each permutation with equal possibility)
// children[v] is vector of children cities of city v
for u in children[v]:
dfs(u)
As told before, Barney will start his journey in the root of the tree (equivalent to call dfs(1)).
Now Barney needs to pack a backpack and so he wants to know more about his upcoming journey: for every city i, Barney wants to know the expected value of starting_time[i]. He's a friend of Jon Snow and knows nothing, that's why he asked for your help.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 105) — the number of cities in USC.
The second line contains n - 1 integers p2, p3, ..., pn (1 ≤ pi < i), where pi is the number of the parent city of city number i in the tree, meaning there is a road between cities numbered pi and i in USC.
Output
In the first and only line of output print n numbers, where i-th number is the expected value of starting_time[i].
Your answer for each city will be considered correct if its absolute or relative error does not exceed 10 - 6.
Examples
Input
7
1 2 1 1 4 4
Output
1.0 4.0 5.0 3.5 4.5 5.0 5.0
Input
12
1 1 2 2 4 4 3 3 1 10 8
Output
1.0 5.0 5.5 6.5 7.5 8.0 8.0 7.0 7.5 6.5 7.5 8.0
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, x, y, si[N];
double ans[N];
int tot, fi[N], a[N], ne[N];
inline void add(int x, int y) {
a[++tot] = y;
ne[tot] = fi[x];
fi[x] = tot;
}
inline void pre(int x) {
si[x] = 1;
for (int i = fi[x]; i; i = ne[i]) pre(a[i]), si[x] += si[a[i]];
}
inline void dfs(int x) {
for (int i = fi[x]; i; i = ne[i]) {
ans[a[i]] = ans[x] + 1 + (si[x] - si[a[i]] - 1) * 0.5;
dfs(a[i]);
}
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) scanf("%d", &x), add(x, i);
pre(1);
ans[1] = 1;
dfs(1);
for (int i = 1; i <= n; ++i) printf("%.10lf ", ans[i]);
return 0;
}
|
Harry Water, Ronaldo, Her-my-oh-knee and their friends have started a new school year at their MDCS School of Speechcraft and Misery. At the time, they are very happy to have seen each other after a long time. The sun is shining, birds are singing, flowers are blooming, and their Potions class teacher, professor Snipe is sulky as usual. Due to his angst fueled by disappointment in his own life, he has given them a lot of homework in Potions class.
Each of the n students has been assigned a single task. Some students do certain tasks faster than others. Thus, they want to redistribute the tasks so that each student still does exactly one task, and that all tasks are finished. Each student has their own laziness level, and each task has its own difficulty level. Professor Snipe is trying hard to improve their work ethics, so each student’s laziness level is equal to their task’s difficulty level. Both sets of values are given by the sequence a, where ai represents both the laziness level of the i-th student and the difficulty of his task.
The time a student needs to finish a task is equal to the product of their laziness level and the task’s difficulty. They are wondering, what is the minimum possible total time they must spend to finish all tasks if they distribute them in the optimal way. Each person should receive one task and each task should be given to one person. Print the answer modulo 10 007.
Input
The first line of input contains integer n (1 ≤ n ≤ 100 000) — the number of tasks. The next n lines contain exactly one integer number ai (1 ≤ ai ≤ 100 000) — both the difficulty of the initial task and the laziness of the i-th students.
Output
Print the minimum total time to finish all tasks modulo 10 007.
Example
Input
2
1
3
Output
6
Note
In the first sample, if the students switch their tasks, they will be able to finish them in 3 + 3 = 6 time units.
|
#include <bits/stdc++.h>
const int MOD = 10007;
const int MAXN = 110001;
int n, a[MAXN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
std::sort(a + 1, a + n + 1);
int answer = 0;
for (int i = 1; i <= n; i++) {
answer = (answer + 1ll * a[i] * a[n - i + 1] % MOD) % MOD;
}
printf("%d\n", answer);
}
|
Tanya is now five so all her friends gathered together to celebrate her birthday. There are n children on the celebration, including Tanya.
The celebration is close to its end, and the last planned attraction is gaming machines. There are m machines in the hall, they are numbered 1 through m. Each of the children has a list of machines he wants to play on. Moreover, for each of the machines he knows the exact time he wants to play on it. For every machine, no more than one child can play on this machine at the same time.
It is evening already, so every adult wants to go home. To speed up the process, you can additionally rent second copies of each of the machines. To rent the second copy of the j-th machine, you have to pay pj burles. After you rent a machine, you can use it for as long as you want.
How long it will take to make every child play according to his plan, if you have a budget of b burles for renting additional machines? There is only one copy of each machine, so it's impossible to rent a third machine of the same type.
The children can interrupt the game in any moment and continue it later. If the i-th child wants to play on the j-th machine, it is allowed after you rent the copy of the j-th machine that this child would play some part of the time on the j-th machine and some part of the time on its copy (each of these parts could be empty). The interruptions and changes take no time and can be performed in any integer moment of time. Of course, a child can't play on more than one machine at the same time.
Remember, that it is not needed to save money (no one saves money at the expense of children happiness!), it is needed to minimize the latest moment of time some child ends his game.
Input
The first line contains three integers n, m and b (1 ≤ n ≤ 40, 1 ≤ m ≤ 10, 0 ≤ b ≤ 106) — the number of children, the number of gaming machines and the budget for renting additional machines.
The second line contains m integers p1, p2, ..., pm (1 ≤ pj ≤ 106), where pj is the rent price for the second copy of the j-th machine.
n lines follow, i-th of them describes the wishes of the i-th child. The line starts with an integer ki (0 ≤ ki ≤ m) — the number of machines, the i-th child wants to play on. Then there are ki pairs in the line, the y-th of them is xiy, tiy. It means that, the i-th child wants to play tiy (1 ≤ tiy ≤ 2500) minutes on the xiy-th (1 ≤ xiy ≤ m) machine. In each of these n lines the values xiy are distinct.
Output
In the first line print the minimum time in which all the children can finish their games.
In the second line print a string of length m consisting of zeros and ones. The j-th character is '1', if the copy of j-th machine should be rated, and '0' otherwise.
In the third line print integer g (0 ≤ g ≤ 106) — the total number of time segments of continuous playing for all of the children. Then in g lines print the segments as four integers i, j, s, d, meaning that the i-th child was playing on the j-th machine or its copy from the time moment s (s ≥ 0) for d minutes (d ≥ 1). You can print these lines in arbitrary order.
If there are multiple answers, print any of them.
Examples
Input
2 2 100
3 7
2 1 3 2 1
2 1 3 2 1
Output
4
10
8
1 1 0 1
2 2 0 1
1 1 1 1
2 1 1 1
2 1 2 1
1 1 2 1
1 2 3 1
2 1 3 1
Input
3 2 15
11 7
2 2 10 1 5
1 2 20
2 1 4 2 3
Output
20
01
17
2 2 0 4
2 2 4 1
1 1 5 2
2 2 5 2
1 2 7 5
2 2 7 5
2 2 12 1
1 2 12 1
3 1 13 4
2 2 13 4
1 2 13 4
1 1 17 2
3 2 17 2
2 2 17 2
1 1 19 1
2 2 19 1
3 2 19 1
|
#include <bits/stdc++.h>
using namespace std;
const int N = 70;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
struct dat {
int i, j, s, d;
};
int mat_r[N], mat_l[N], n, m, b, id[N], sx[N], sy[N], p[N], w[N][N];
bool dup[N], vis[N];
vector<dat> opt;
bool find(int u) {
for (int v = 1; v <= n + m; v++)
if (w[u][v] > 0 && !vis[v]) {
vis[v] = 1;
if (!mat_r[v] || find(mat_r[v])) {
mat_r[v] = u;
return 1;
}
}
return 0;
}
bool cmp(int a, int b) { return sy[a] < sy[b]; }
int main() {
cin >> n >> m >> b;
for (int i = 1; i <= m; i++) p[i] = gi();
for (int i = 1; i <= n; i++) {
int k = gi();
while (k--) {
int id = gi(), t = gi();
w[i][id] = t;
sx[i] += t;
sy[id] += t;
}
}
for (int i = 1; i <= m; i++) id[i] = i;
sort(id + 1, id + m + 1, cmp);
int pref = 0;
for (int i = m; i; i--) {
if (b >= p[id[i]])
b -= p[id[i]], dup[id[i]] = 1;
else {
pref = i;
break;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) ans = max(ans, sx[i]);
for (int i = 1; i <= pref; i++) ans = max(ans, sy[id[i]]);
for (int i = pref + 1; i <= m; i++) ans = max(ans, (sy[id[i]] + 1) / 2);
cout << ans << '\n';
for (int i = 1; i <= m; i++) cout << dup[i];
cout << '\n';
for (int i = 1; i <= m; i++)
if (dup[i]) sy[i] = sy[i + m] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (dup[j]) {
int tmp = w[i][j];
w[i][j] = tmp / 2;
w[i][j + m] = tmp / 2;
if (tmp & 1) {
if (sy[j] < sy[j + m])
++w[i][j];
else
++w[i][j + m];
}
sy[j] += w[i][j];
sy[j + m] += w[i][j + m];
}
m <<= 1;
for (int i = 1; i <= n; i++) {
w[i][i + m] = ans - sx[i];
sx[i] += w[i][i + m];
sy[i + m] += w[i][i + m];
}
for (int i = 1; i <= m; i++) {
w[i + n][i] = ans - sy[i];
sx[i + n] += w[i + n][i];
sy[i] += w[i + n][i];
}
for (int i = n + 1; i <= n + m; i++)
for (int j = m + 1; j <= m + n; j++) {
w[i][j] = ans - max(sx[i], sy[j]);
sx[i] += w[i][j];
sy[j] += w[i][j];
}
int now = 0;
while (now < ans) {
memset(mat_r, 0, sizeof(mat_r));
for (int i = 1; i <= n + m; i++) {
memset(vis, 0, sizeof(vis));
assert(find(i));
}
for (int i = 1; i <= n + m; i++) mat_l[mat_r[i]] = i;
int mn = 1e9;
for (int i = 1; i <= n + m; i++) {
mn = min(mn, w[i][mat_l[i]]);
}
for (int i = 1; i <= n + m; i++) {
if (i <= n && mat_l[i] <= m) opt.push_back((dat){i, mat_l[i], now, mn});
w[i][mat_l[i]] -= mn;
}
now += mn;
}
cout << int(opt.size()) << '\n';
for (auto t : opt)
cout << t.i << ' ' << (t.j - 1) % (m / 2) + 1 << ' ' << t.s << ' ' << t.d
<< '\n';
return 0;
}
|
Dasha logged into the system and began to solve problems. One of them is as follows:
Given two sequences a and b of length n each you need to write a sequence c of length n, the i-th element of which is calculated as follows: ci = bi - ai.
About sequences a and b we know that their elements are in the range from l to r. More formally, elements satisfy the following conditions: l ≤ ai ≤ r and l ≤ bi ≤ r. About sequence c we know that all its elements are distinct.
<image>
Dasha wrote a solution to that problem quickly, but checking her work on the standard test was not so easy. Due to an error in the test system only the sequence a and the compressed sequence of the sequence c were known from that test.
Let's give the definition to a compressed sequence. A compressed sequence of sequence c of length n is a sequence p of length n, so that pi equals to the number of integers which are less than or equal to ci in the sequence c. For example, for the sequence c = [250, 200, 300, 100, 50] the compressed sequence will be p = [4, 3, 5, 2, 1]. Pay attention that in c all integers are distinct. Consequently, the compressed sequence contains all integers from 1 to n inclusively.
Help Dasha to find any sequence b for which the calculated compressed sequence of sequence c is correct.
Input
The first line contains three integers n, l, r (1 ≤ n ≤ 105, 1 ≤ l ≤ r ≤ 109) — the length of the sequence and boundaries of the segment where the elements of sequences a and b are.
The next line contains n integers a1, a2, ..., an (l ≤ ai ≤ r) — the elements of the sequence a.
The next line contains n distinct integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the compressed sequence of the sequence c.
Output
If there is no the suitable sequence b, then in the only line print "-1".
Otherwise, in the only line print n integers — the elements of any suitable sequence b.
Examples
Input
5 1 5
1 1 1 1 1
3 1 5 4 2
Output
3 1 5 4 2
Input
4 2 9
3 4 8 9
3 2 1 4
Output
2 2 2 9
Input
6 1 5
1 1 1 1 1 1
2 3 5 4 1 6
Output
-1
Note
Sequence b which was found in the second sample is suitable, because calculated sequence c = [2 - 3, 2 - 4, 2 - 8, 9 - 9] = [ - 1, - 2, - 6, 0] (note that ci = bi - ai) has compressed sequence equals to p = [3, 2, 1, 4].
|
#include <bits/stdc++.h>
void probs();
int main() {
probs();
return 0;
}
void probs() {
int n, l, r, *a, *b;
scanf("%d%d%d", &n, &l, &r);
int k, max;
a = (int*)malloc(n * sizeof(int));
b = (int*)malloc(n * sizeof(int));
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
b[i] = a[i] + b[i];
}
max = b[0];
for (int i = 1; i < n; i++) {
if (b[i] > max) max = b[i];
}
k = max - r;
for (int i = 0; i < n; i++) {
b[i] -= k;
if (b[i] < l) {
printf("%d", -1);
return;
}
}
for (int i = 0; i < n; i++) printf("%d ", b[i]);
free(a);
free(b);
}
|
You are developing a new feature for the website which sells airline tickets: being able to sort tickets by price! You have already extracted the tickets' prices, so there's just the last step to be done...
You are given an array of integers. Sort it in non-descending order.
Input
The input consists of a single line of space-separated integers. The first number is n (1 ≤ n ≤ 10) — the size of the array. The following n numbers are the elements of the array (1 ≤ ai ≤ 100).
Output
Output space-separated elements of the sorted array.
Example
Input
3 3 1 2
Output
1 2 3
Note
Remember, this is a very important feature, and you have to make sure the customers appreciate it!
|
a = input()[2:]
n = [0 for i in range(1000000)]
g = 123
for i in range(130000):
g *= 3
a = list(map(int, a.split()))
x = [0 for _ in range(len(a))]
for i in range(len(x)):
x[i] = min(a)
a.remove(x[i])
for o in x:
print(o, end=' ')
|
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;
int col[300010], flag[300010];
vector<int> ice[300010];
vector<int> edge[300010];
int dfn;
void dfs(int u, int f) {
for (int ic : ice[u]) {
if (col[ic]) {
flag[col[ic]] = dfn;
}
}
int cur = 1;
for (int ic : ice[u]) {
if (!col[ic]) {
while (flag[cur] == dfn) cur++;
col[ic] = cur;
cur++;
}
}
dfn++;
for (int v : edge[u]) {
if (v != f) {
dfs(v, u);
}
}
}
int main() {
int n, m, s;
scanf("%d%d", &n, &m);
int ret = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &s);
ret = max(ret, s);
int t;
for (int j = 0; j < s; j++) {
scanf("%d", &t);
ice[i].push_back(t);
}
}
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
dfn = 1;
dfs(1, -1);
printf("%d\n", ret);
for (int i = 1; i <= m; i++) {
if (!col[i]) col[i] = 1;
printf("%d ", col[i]);
}
return 0;
}
|
Developer Petr thinks that he invented a perpetual motion machine. Namely, he has a lot of elements, which work in the following way.
Each element has one controller that can be set to any non-negative real value. If a controller is set on some value x, then the controller consumes x2 energy units per second. At the same time, any two elements connected by a wire produce y·z energy units per second, where y and z are the values set on their controllers.
Petr has only a limited number of wires, so he has already built some scheme of elements and wires, and is now interested if it's possible to set the controllers in such a way that the system produces at least as much power as it consumes, and at least one controller is set on the value different from 0. Help him check this, and if it's possible, find the required integer values that should be set.
It is guaranteed that if there exist controllers' settings satisfying the above conditions, then there exist required integer values not greater than 106.
Input
There are several (at least one) test cases in the input. The first line contains single integer — the number of test cases.
There is an empty line before each test case. The first line of test case contains two integers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ 105) — the number of elements in the scheme and the number of wires.
After that, m lines follow, each of them contains two integers a and b (1 ≤ a, b ≤ n) — two elements connected by a wire. No element is connected with itself, no two elements are connected by more than one wire.
It is guaranteed that the sum of n and the sum of m over all test cases do not exceed 105.
For hacks you can only use tests with one test case.
Output
Print answer for each test case.
For each test case print "YES" if it's possible to set the controllers in such a way that the consumed power is not greater than the power produced, and the required values on the next line. The settings should be integers from 0 to 106, inclusive, and at least one value should be different from 0. If there are multiple answers, print any of them.
If it's not possible to set the controllers in the required way, print one line "NO".
Example
Input
4
4 4
1 2
2 3
3 4
4 2
3 2
2 3
3 1
4 6
1 2
3 4
4 2
1 4
1 3
3 2
10 9
2 1
3 2
5 2
6 2
2 7
2 8
2 9
2 10
4 2
Output
YES
1 2 2 1
NO
YES
1 1 1 1
YES
1 5 1 1 1 1 1 1 1 1
Note
In the first example it's possible to set the controllers in the required way, for example, in the following way: set 1 on the first element, set 2 on the second and on the third, set 1 on the fourth. The consumed power is then equal to 12 + 22 + 22 + 12 = 10 energy units per second, the produced power is equal to 1·2 + 2·2 + 2·1 + 2·1 = 10 energy units per second. Thus the answer is "YES".
In the second test case it's not possible to set the controllers in the required way. For example, if we set all controllers to 0.5, then the consumed powers equals 0.75 energy units per second, while produced power equals 0.5 energy units per second.
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[111111];
int n, m, s[111111], vis[111111], b[111111];
int l, p[111111], f, ans[111111];
void print() {
f = 1;
printf("YES\n");
int i;
for (i = 1; i < n; i = i + 1) printf("%d ", ans[i]);
printf("%d\n", ans[n]);
}
void s4(int x) {
int i;
ans[x] = 2;
for (i = 0; i < 4; i = i + 1) ans[v[x][i]] = 1;
print();
}
void cyc(int x) {
int i;
i = l;
while (p[i] != x) {
ans[p[i]] = 1;
i--;
}
ans[x] = 1;
print();
}
void s3s3(int x) {
int i, t;
t = p[1];
for (i = 0; i < 3; i = i + 1) ans[v[t][i]] = 1;
t = x;
for (i = 0; i < 3; i = i + 1) ans[v[t][i]] = 1;
for (i = 1; i <= l; i = i + 1) ans[p[i]] = 2;
print();
}
void sv(int x, int y, int z) {
int i, t;
t = y * z;
for (i = 1; i <= y; i = i + 1) {
ans[x] = t;
x = p[x];
t -= z;
}
}
void s3_222(int u, int x, int y, int z) {
ans[u] = 3;
sv(x, 2, 1);
sv(y, 2, 1);
sv(z, 2, 1);
print();
}
void s3_133(int u, int x, int y, int z) {
ans[u] = 4;
sv(x, 1, 2);
sv(y, 3, 1);
sv(z, 3, 1);
print();
}
void s3_125(int u, int x, int y, int z) {
ans[u] = 6;
sv(x, 1, 3);
sv(y, 2, 2);
sv(z, 5, 1);
print();
}
void dfs1(int u, int fa) {
if (f) return;
int i;
vis[u] = 1;
b[u] = 1;
l++;
p[l] = u;
for (i = 0; i < s[u]; i = i + 1) {
if (f) return;
if (v[u][i] == fa) continue;
if (b[v[u][i]]) {
cyc(v[u][i]);
return;
}
dfs1(v[u][i], u);
}
p[l] = 0;
l--;
b[u] = 0;
}
void dfs2(int u, int fa) {
if (f) return;
int i;
vis[u] = 1;
l++;
p[l] = u;
if (l > 1 && s[u] >= 3) {
s3s3(u);
return;
}
for (i = 0; i < s[u]; i = i + 1) {
if (f) return;
if (v[u][i] != fa) dfs2(v[u][i], u);
}
p[l] = 0;
l--;
}
int dfs3(int u, int fa) {
int i, x;
p[u] = 0;
x = 0;
for (i = 0; i < s[u]; i = i + 1)
if (v[u][i] != fa) {
x = max(x, dfs3(v[u][i], u));
p[u] = v[u][i];
}
return x + 1;
}
int main() {
int T, i, j, x, y, z;
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (i = 0; i <= n; i = i + 1) {
v[i].clear();
s[i] = 0;
vis[i] = 0;
p[i] = 0;
ans[i] = 0;
b[i] = 0;
}
l = 0;
f = 0;
for (i = 1; i <= m; i = i + 1) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
s[x]++;
s[y]++;
}
for (i = 1; i <= n && !f; i = i + 1)
if (s[i] >= 4) s4(i);
if (f) continue;
for (i = 1; i <= n && !f; i = i + 1) {
if (!vis[i]) dfs1(i, 0);
}
if (f) continue;
for (i = 0; i <= n; i = i + 1) {
vis[i] = 0;
p[i] = 0;
b[i] = 0;
}
l = 0;
for (i = 1; i <= n && !f; i = i + 1) {
if (!vis[i] && s[i] >= 3) dfs2(i, 0);
}
if (f) continue;
for (i = 0; i <= n; i = i + 1) {
vis[i] = 0;
p[i] = 0;
b[i] = 0;
}
l = 0;
for (i = 1; i <= n && !f; i = i + 1) {
if (s[i] >= 3) {
x = dfs3(v[i][0], i);
y = dfs3(v[i][1], i);
z = dfs3(v[i][2], i);
if (x > y) {
swap(v[i][0], v[i][1]);
swap(x, y);
}
if (y > z) {
swap(v[i][1], v[i][2]);
swap(y, z);
}
if (x > y) {
swap(v[i][0], v[i][1]);
swap(x, y);
}
if (x >= 2)
s3_222(i, v[i][0], v[i][1], v[i][2]);
else {
if (y >= 3) s3_133(i, v[i][0], v[i][1], v[i][2]);
if (y == 2 && z >= 5) s3_125(i, v[i][0], v[i][1], v[i][2]);
}
}
}
if (f) continue;
printf("NO\n");
}
return 0;
}
|
John gave Jack a very hard problem. He wrote a very big positive integer A0 on a piece of paper. The number is less than 10200000 . In each step, Jack is allowed to put ' + ' signs in between some of the digits (maybe none) of the current number and calculate the sum of the expression. He can perform the same procedure on that sum and so on. The resulting sums can be labeled respectively by A1, A2 etc. His task is to get to a single digit number.
The problem is that there is not much blank space on the paper. There are only three lines of space, so he can't perform more than three steps. Since he wants to fill up the paper completely, he will perform exactly three steps.
Jack must not add leading zeros to intermediate results, but he can put ' + ' signs in front of digit 0. For example, if the current number is 1000100, 10 + 001 + 00 is a valid step, resulting in number 11.
Input
First line contains a positive integer N (1 ≤ N ≤ 200000), representing the number of digits of A0.
Second line contains a string of length N representing positive integer number A0. Each character is digit. There will be no leading zeros.
Output
Output exactly three lines, the steps Jack needs to perform to solve the problem. You can output any sequence of steps which results in a single digit number (and is logically consistent).
Every step consists of digits and ' + ' signs. Steps should not contain several ' + ' signs in a row, whitespaces, or ' + ' signs as the first or last character. They also need to be arithmetically consistent.
Solution might not be unique. Output any of them in that case.
Examples
Input
1
1
Output
1
1
1
Input
4
5806
Output
5+8+0+6
1+9
1+0
Note
In the first sample, Jack can't put ' + ' signs anywhere, so he just writes 1 in each line and solves the problem. Here, solution is unique.
In the second sample, Jack first puts ' + ' between every two consecutive digits, thus getting the result 5 + 8 + 0 + 6 = 19. He does the same on the second step, getting 1 + 9 = 10. Once more, he gets 1 + 0 = 1, so after three steps, the result is 1 and his solution is correct.
|
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
class CerrDummy {
} cerrDummy;
template <class T>
CerrDummy& operator<<(CerrDummy& cd, const T&) {
return cd;
}
using charTDummy = char;
using traitsDummy = char_traits<charTDummy>;
CerrDummy& operator<<(CerrDummy& cd,
basic_ostream<charTDummy, traitsDummy>&(
basic_ostream<charTDummy, traitsDummy>&)) {
return cd;
}
using pi = pair<ll, ll>;
using vi = vector<ll>;
using ld = long double;
template <class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (ll i = ll(0); i < ll((ll)v.size()); i++) {
if (i) os << ",";
os << v[i];
}
os << "}";
return os;
}
ll read() {
ll i;
scanf("%" SCNd64, &i);
return i;
}
void printSpace() { printf(" "); }
void printEoln() { printf("\n"); }
void print(ll x, ll suc = 1) {
printf("%" PRId64, x);
if (suc == 1) printEoln();
if (suc == 2) printSpace();
}
string readString() {
static char buf[3341000];
scanf("%s", buf);
return string(buf);
}
char* readCharArray() {
static char buf[3341000];
static ll bufUsed = 0;
char* ret = buf + bufUsed;
scanf("%s", ret);
bufUsed += strlen(ret) + 1;
return ret;
}
template <class T, class U>
void chmax(T& a, U b) {
if (a < b) a = b;
}
template <class T, class U>
void chmin(T& a, U b) {
if (b < a) a = b;
}
template <class T>
T Sq(const T& t) {
return t * t;
}
void Yes(bool ex = true) {
cout << "YES" << endl;
if (ex) exit(0);
}
void No(bool ex = true) {
cout << "NO" << endl;
if (ex) exit(0);
}
const ll infLL = LLONG_MAX / 3;
const ll inf = infLL;
bool waf(string s, bool show) {
ll n = s.size();
for (ll bit = ll(0); bit < ll(1 << (n - 1)); bit++) {
ll sum = 0, cur = 0;
for (ll i = ll(0); i < ll(n); i++) {
if (i > 0 && (bit >> (i - 1)) & 1) {
sum += cur;
cur = 0;
}
cur = cur * 10 + s[i] - '0';
}
sum += cur;
string tmp = to_string(sum);
ll d = 0;
for (auto c : tmp) d += c - '0';
if (d < 10) {
if (show) {
{
string t;
for (ll i = ll(0); i < ll(n); i++) {
if (i > 0 && (bit >> (i - 1)) & 1) {
t += '+';
}
t += s[i];
}
cout << t << endl;
}
{
string t;
for (ll i = ll(0); i < ll(tmp.size()); i++) {
if (i) t += '+';
t += tmp[i];
}
cout << t << endl;
}
}
return true;
}
}
return false;
}
signed main() {
ll n = read();
string s;
if (n > 0) {
s = readString();
} else {
if (n == -1) {
n = 23;
s += '1';
for (ll i = ll(1); i < ll(n); i++) s += '9';
} else {
n = 199999;
for (ll i = ll(0); i < ll(n); i++) s += '9';
}
}
cerrDummy << s << endl;
for (ll b = 100; b >= 1; b--) {
string t;
ll sum = 0, cur = 0;
for (ll i = ll(0); i < ll(n); i++) {
if (i && rand() % b) {
sum += cur;
cur = 0;
t += '+';
}
t += s[i];
cur *= 10;
cur += (s[i] - '0');
}
sum += cur;
if (!waf(to_string(sum), false)) continue;
cout << t << endl;
waf(to_string(sum), true);
break;
}
}
|
You are given a multiset of n integers. You should select exactly k of them in a such way that the difference between any two of them is divisible by m, or tell that it is impossible.
Numbers can be repeated in the original multiset and in the multiset of selected numbers, but number of occurrences of any number in multiset of selected numbers should not exceed the number of its occurrences in the original multiset.
Input
First line contains three integers n, k and m (2 ≤ k ≤ n ≤ 100 000, 1 ≤ m ≤ 100 000) — number of integers in the multiset, number of integers you should select and the required divisor of any pair of selected integers.
Second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109) — the numbers in the multiset.
Output
If it is not possible to select k numbers in the desired way, output «No» (without the quotes).
Otherwise, in the first line of output print «Yes» (without the quotes). In the second line print k integers b1, b2, ..., bk — the selected numbers. If there are multiple possible solutions, print any of them.
Examples
Input
3 2 3
1 8 4
Output
Yes
1 4
Input
3 3 3
1 8 4
Output
No
Input
4 3 5
2 7 7 7
Output
Yes
2 7 7
|
import java.util.Scanner;
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author tula4
*/
public class C00441D2PB {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int k = in.nextInt();
int m = in.nextInt();
int[] a = new int[n];
int[] count = new int[m];
int maxR = -1;
for (int i = 0; i < n; i++) {
a[i] = in.nextInt();
int r = a[i] % m;
count[r]++;
if (count[r] == k) {
maxR = r;
break;
}
}
if (maxR == -1) {
System.out.println("No");
} else {
System.out.println("Yes");
int countSameR = 0;
for (int i = 0; i < n; i++) {
int r = a[i] % m;
if (r == maxR) {
System.out.print(a[i] + " ");
countSameR++;
if (countSameR == k) {
break;
}
}
}
}
}
}
|
The whole world got obsessed with robots,and to keep pace with the progress, great Berland's programmer Draude decided to build his own robot. He was working hard at the robot. He taught it to walk the shortest path from one point to another, to record all its movements, but like in many Draude's programs, there was a bug — the robot didn't always walk the shortest path. Fortunately, the robot recorded its own movements correctly. Now Draude wants to find out when his robot functions wrong. Heh, if Draude only remembered the map of the field, where he tested the robot, he would easily say if the robot walked in the right direction or not. But the field map was lost never to be found, that's why he asks you to find out if there exist at least one map, where the path recorded by the robot is the shortest.
The map is an infinite checkered field, where each square is either empty, or contains an obstruction. It is also known that the robot never tries to run into the obstruction. By the recorded robot's movements find out if there exist at least one such map, that it is possible to choose for the robot a starting square (the starting square should be empty) such that when the robot moves from this square its movements coincide with the recorded ones (the robot doesn't run into anything, moving along empty squares only), and the path from the starting square to the end one is the shortest.
In one movement the robot can move into the square (providing there are no obstrutions in this square) that has common sides with the square the robot is currently in.
Input
The first line of the input file contains the recording of the robot's movements. This recording is a non-empty string, consisting of uppercase Latin letters L, R, U and D, standing for movements left, right, up and down respectively. The length of the string does not exceed 100.
Output
In the first line output the only word OK (if the above described map exists), or BUG (if such a map does not exist).
Examples
Input
LLUUUR
Output
OK
Input
RRUULLDD
Output
BUG
|
/* start initial cell as (0,0)
The main idea is that :
1)a cell can not repeat.
2)if 2 cell are adjacent then absolute difference between steps taken to reach these cells should be one
*/
import java.io.*;
import java.util.*;
public class pt
{
static class pair{
int x,y;
pair(int a,int b){
x=a;
y=b;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
pair other = (pair) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
@Override
public int hashCode() {
return(x-y);
}
}
public static void main (String[] args)
{
FastReader sc=new FastReader();
PrintWriter out = new PrintWriter(System.out);
HashMap<pair,Integer> hm = new HashMap<pair,Integer>();
pair p = new pair(0,0);
int x=0,y=0,s=0; // s is steps and (x,y) represents initial steps
hm.put(p,0);
String str = sc.next();
String res ="OK";
for(int i=0;i<str.length();i++){
if(str.charAt(i)=='L')
x--;
else if(str.charAt(i)=='R')
x++;
else if(str.charAt(i)=='U')
y++;
else
y--;
s++;
pair p1 = new pair(x,y);
if(!hm.containsKey(p1)){
pair p2 = new pair(x-1,y);
pair p3 = new pair(x+1,y);
pair p4 = new pair(x,y+1);
pair p5 = new pair(x,y-1);
if((hm.containsKey(p2)&&(s-hm.get(p2))>1)||(hm.containsKey(p3)&&(s-hm.get(p3))>1)
||(hm.containsKey(p4)&&(s-hm.get(p4))>1)||(hm.containsKey(p5)&&(s-hm.get(p5))>1))
{ res = "BUG" ; break;}
else
hm.put(p1,s);
}
else
{ res = "BUG" ; break;}
}
out.println(res);
out.flush();
}
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;
}
}
}
|
Imp likes his plush toy a lot.
<image>
Recently, he found a machine that can clone plush toys. Imp knows that if he applies the machine to an original toy, he additionally gets one more original toy and one copy, and if he applies the machine to a copied toy, he gets two additional copies.
Initially, Imp has only one original toy. He wants to know if it is possible to use machine to get exactly x copied toys and y original toys? He can't throw toys away, and he can't apply the machine to a copy if he doesn't currently have any copies.
Input
The only line contains two integers x and y (0 ≤ x, y ≤ 109) — the number of copies and the number of original toys Imp wants to get (including the initial one).
Output
Print "Yes", if the desired configuration is possible, and "No" otherwise.
You can print each letter in arbitrary case (upper or lower).
Examples
Input
6 3
Output
Yes
Input
4 2
Output
No
Input
1000 1001
Output
Yes
Note
In the first example, Imp has to apply the machine twice to original toys and then twice to copies.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int copies, original;
cin >> copies >> original;
if (copies == 0 && original == 1) {
cout << "Yes" << endl;
exit(0);
}
if (copies >= original - 1) {
if ((copies - original + 1) % 2 == 0 && original > 1) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else {
cout << "No" << endl;
}
return 0;
}
|
One day Igor K. stopped programming and took up math. One late autumn evening he was sitting at a table reading a book and thinking about something.
The following statement caught his attention: "Among any six people there are either three pairwise acquainted people or three pairwise unacquainted people"
Igor just couldn't get why the required minimum is 6 people. "Well, that's the same for five people, too!" — he kept on repeating in his mind. — "Let's take, say, Max, Ilya, Vova — here, they all know each other! And now let's add Dima and Oleg to Vova — none of them is acquainted with each other! Now, that math is just rubbish!"
Igor K. took 5 friends of his and wrote down who of them is friends with whom. Now he wants to check whether it is true for the five people that among them there are either three pairwise acquainted or three pairwise not acquainted people.
Input
The first line contains an integer m (0 ≤ m ≤ 10), which is the number of relations of acquaintances among the five friends of Igor's.
Each of the following m lines contains two integers ai and bi (1 ≤ ai, bi ≤ 5;ai ≠ bi), where (ai, bi) is a pair of acquainted people. It is guaranteed that each pair of the acquaintances is described exactly once. The acquaintance relation is symmetrical, i.e. if x is acquainted with y, then y is also acquainted with x.
Output
Print "FAIL", if among those five people there are no either three pairwise acquainted or three pairwise unacquainted people. Otherwise print "WIN".
Examples
Input
4
1 3
2 3
1 4
5 3
Output
WIN
Input
5
1 2
2 3
3 4
4 5
5 1
Output
FAIL
|
e = [[False] * 5 for i in range(5)]
for i in range(int(input())):
a, b = map(int, input().split())
e[a - 1][b - 1] = e[b - 1][a - 1] = True
for a in range(3):
for b in range(a + 1, 4):
for c in range(b + 1, 5):
if len({e[a][b], e[a][c], e[b][c]}) == 1:
print('WIN')
exit()
print('FAIL')
|
You are given an integer array of length n.
You have to choose some subsequence of this array of maximum length such that this subsequence forms a increasing sequence of consecutive integers. In other words the required sequence should be equal to [x, x + 1, ..., x + k - 1] for some value x and length k.
Subsequence of an array can be obtained by erasing some (possibly zero) elements from the array. You can erase any elements, not necessarily going successively. The remaining elements preserve their order. For example, for the array [5, 3, 1, 2, 4] the following arrays are subsequences: [3], [5, 3, 1, 2, 4], [5, 1, 4], but the array [1, 3] is not.
Input
The first line of the input containing integer number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array. The second line of the input containing n integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the array itself.
Output
On the first line print k — the maximum length of the subsequence of the given array that forms an increasing sequence of consecutive integers.
On the second line print the sequence of the indices of the any maximum length subsequence of the given array that forms an increasing sequence of consecutive integers.
Examples
Input
7
3 3 4 7 5 6 8
Output
4
2 3 5 6
Input
6
1 3 5 2 4 6
Output
2
1 4
Input
4
10 9 8 7
Output
1
1
Input
9
6 7 8 3 4 5 9 10 11
Output
6
1 2 3 7 8 9
Note
All valid answers for the first example (as sequences of indices):
* [1, 3, 5, 6]
* [2, 3, 5, 6]
All valid answers for the second example:
* [1, 4]
* [2, 5]
* [3, 6]
All valid answers for the third example:
* [1]
* [2]
* [3]
* [4]
All valid answers for the fourth example:
* [1, 2, 3, 7, 8, 9]
|
#include <bits/stdc++.h>
using namespace std;
void printReverse(int u, vector<int> &tr) {
if (u == -1) {
return;
}
printReverse(tr[u] - 1, tr);
cout << u + 1 << ' ';
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> a(n), tr(n);
pair<int, int> mx = {0, 0};
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
map<int, pair<int, int> > f;
for (int i = 0; i < n; ++i) {
if (!f.count(a[i] - 1)) {
if (!f.count(a[i])) {
f[a[i]] = {1, i};
}
} else if (!f.count(a[i]) || f[a[i]].first < f[a[i] - 1].first + 1) {
f[a[i]] = {f[a[i] - 1].first + 1, i};
tr[i] = f[a[i] - 1].second + 1;
}
if (mx.first < f[a[i]].first) {
mx = {f[a[i]].first, i};
}
}
cout << mx.first << '\n';
printReverse(mx.second, tr);
}
|
Consider a tree (that is, an undirected connected graph without loops) T_1 and a tree T_2. Let's define their cartesian product T_1 × T_2 in a following way.
Let V be the set of vertices in T_1 and U be the set of vertices in T_2.
Then the set of vertices of graph T_1 × T_2 is V × U, that is, a set of ordered pairs of vertices, where the first vertex in pair is from V and the second — from U.
Let's draw the following edges:
* Between (v, u_1) and (v, u_2) there is an undirected edge, if u_1 and u_2 are adjacent in U.
* Similarly, between (v_1, u) and (v_2, u) there is an undirected edge, if v_1 and v_2 are adjacent in V.
Please see the notes section for the pictures of products of trees in the sample tests.
Let's examine the graph T_1 × T_2. How much cycles (not necessarily simple) of length k it contains? Since this number can be very large, print it modulo 998244353.
The sequence of vertices w_1, w_2, ..., w_k, where w_i ∈ V × U called cycle, if any neighboring vertices are adjacent and w_1 is adjacent to w_k. Cycles that differ only by the cyclic shift or direction of traversal are still considered different.
Input
First line of input contains three integers — n_1, n_2 and k (2 ≤ n_1, n_2 ≤ 4000, 2 ≤ k ≤ 75) — number of vertices in the first tree, number of vertices in the second tree and the cycle length respectively.
Then follow n_1 - 1 lines describing the first tree. Each of this lines contains two integers — v_i, u_i (1 ≤ v_i, u_i ≤ n_1), which define edges of the first tree.
Then follow n_2 - 1 lines, which describe the second tree in the same format.
It is guaranteed, that given graphs are trees.
Output
Print one integer — number of cycles modulo 998244353.
Examples
Input
2 2 2
1 2
1 2
Output
8
Input
2 2 4
1 2
1 2
Output
32
Input
2 3 4
1 2
1 2
1 3
Output
70
Input
4 2 2
1 2
1 3
1 4
1 2
Output
20
Note
The following three pictures illustrate graph, which are products of the trees from sample tests.
In the first example, the list of cycles of length 2 is as follows:
* «AB», «BA»
* «BC», «CB»
* «AD», «DA»
* «CD», «DC»
<image> <image> <image>
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4001, mod = 998244353;
vector<int> g[maxn];
int n, m, k, c[80][80];
int sz[maxn], used[maxn];
int dp1[maxn][80], dp2[maxn][80];
int ANS, ans[80], ans1[80], ans2[80];
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
void dfs(int v, int p) {
sz[v] = 1;
for (auto to : g[v])
if (!used[to] && to != p) {
dfs(to, v);
sz[v] += sz[to];
}
}
int getctr(int v, int p, int SZ) {
for (auto to : g[v])
if (!used[to] && to != p && sz[to] > SZ / 2) return getctr(to, v, SZ);
return v;
}
void calc_dp(int v, int p, int len, int ban) {
for (auto to : g[v])
if (!used[to]) {
if (to != p) calc_dp(to, v, len, ban);
if (to != ban) add(dp1[to][len], dp1[v][len - 1]);
add(dp2[to][len], dp2[v][len - 1]);
}
}
void calc_ans(int v, int p) {
for (int i = 0; i <= k; i++)
for (int j = 0; j + i <= k; j++)
add(ans[i + j], 1ll * dp1[v][i] * dp2[v][j] % mod);
for (auto to : g[v])
if (!used[to] && to != p) calc_ans(to, v);
}
void solve(int v) {
dfs(v, v);
int ctr = getctr(v, v, sz[v]);
for (int i = 1; i <= n; i++)
for (int j = 0; j <= k; j++) dp1[i][j] = dp2[i][j] = 0;
dp1[ctr][0] = 1;
dp2[ctr][0] = 1;
for (int len = 1; len <= k; len++) calc_dp(ctr, ctr, len, ctr);
calc_ans(ctr, ctr);
used[ctr] = 1;
for (auto to : g[ctr])
if (!used[to]) solve(to);
}
int main() {
for (int i = 0; i < 80; i++) c[0][i] = 1;
for (int i = 1; i < 80; i++)
for (int j = 1; j <= i; j++)
c[j][i] = (c[j - 1][i - 1] + c[j][i - 1]) % mod;
scanf("%d%d%d", &n, &m, &k);
if (k & 1) cout << 0, exit(0);
for (int i = 1; i < n; i++) {
int v, u;
scanf("%d%d", &v, &u);
g[v].push_back(u);
g[u].push_back(v);
}
solve(1);
for (int i = 0; i <= k; i++) {
ans1[i] = ans[i];
ans[i] = 0;
}
n = m;
for (int i = 0; i < maxn; i++) {
used[i] = 0;
g[i].clear();
}
for (int i = 1; i < n; i++) {
int v, u;
scanf("%d%d", &v, &u);
g[v].push_back(u);
g[u].push_back(v);
}
solve(1);
for (int i = 0; i <= k; i++) {
ans2[i] = ans[i];
ans[i] = 0;
}
for (int i = 0; i <= k; i++)
add(ANS, 1ll * ans1[i] * ans2[k - i] % mod * c[i][k] % mod);
cout << ANS;
}
|
Limak is an old brown bear.
He often goes bowling with his friends.
For rolling a ball one gets a score - a non-negative integer number of points.
Score for the i-th roll is multiplied by i and scores are summed up.
For example, for rolls with scores 7, 10, 5 the total score is equal to 7×1 + 10×2 + 5×3 = 42.
Limak made N rolls and got a score Ai for the i-th of them.
Unfortunately, the bowling club's computer system isn't stable today.
Any rolls can be erased!
Then, the total score is calculated as if there were only non-erased rolls.
There are 2^N possible sequences of remaining (non-erased) rolls.
Limak is curious about various statistics of this situation.
He asks you for one thing.
Find the sum of total scores of all 2^N possible sequences of remaining rolls.
Print it modulo 10^9+7.
Input format
The first line contains a single integer N.
The second line contains N non-negative integers A1, A2, ..., AN.
Output format
In a single line print modulo 10^9+7 the sum of total scores of possible remaining sequences.
Constraints
1 ≤ N ≤ 200,000
0 ≤ Ai ≤ 10^9
SAMPLE INPUT
3
6 12 8
SAMPLE OUTPUT
160
Explanation
There are eight possible remaining subsequences.
{} - 0
{6} - 6
{12} - 12
{8} - 8
{6, 12} - 30
{6, 8} - 22
{12, 8} - 28
{6, 12, 8} - 54
0 + 6 + 12 + 8 + 30 + 22 + 28 + 54 = 160
|
s=0
mod=(10**9)+7
n=input()
c=pow(2,n-1,mod)
d=pow(2,abs(n-2),mod)
arr=map(int,raw_input().split())
for i in xrange(n):
s=((s%mod)+((arr[i]*c)%mod))%mod
c=((c%mod)+(d%mod))%mod
print s%mod
|
In PIET's CS Deparment there is a contest of Geometry. In this contest students are told to find minimum angle between hour and minute hand.
Input:
The first line contains the number of test cases, T. T lines follow, each of which contains two integer Hour hand H and minute hand M .
Output:
Print the minimum angle between the hands.
Constraints
1 ≤ T ≤ 100
01 ≤ H ≤ 12
01 ≤ M ≤ 59
SAMPLE INPUT
2
12 30
06 00
SAMPLE OUTPUT
165
180
Explanation
In first input time is 12:30 i.e. hour hand is in middle of 12 and 1 & minute hand is pointing at 6 which makes angle of 165 degrees.
In Second input time is 06:00 i.e. hour hand is at 12 and minute hand is at 6 which makes angle of 180 degrees.
|
for _ in xrange(input()):
hr,mn=map(int,raw_input().split())
if hr==12:
hr=0
ahr=int(hr*30)+int(mn*0.5)
amn=int(mn*6)
angle=abs(ahr-amn)
if angle>180:
angle=360-angle
print angle
|
Ma5termind and Subway are bored of their normal life.They want to do something interesting so that they can enjoy their last sem of college life.As usual Ma5termind comes up with a simple and interesting game.
Ma5termind gives Subway a compressed string. A compressed String is composed of characters and numbers.Every character in a compressed string contains a number. Ex a3b1c2 it represents aaabcc. Other compressed string could be a22b2a1 , z5c2x36. Each number in the compressed string indicates the number of times the corresponding character occurs in the string. The final string is 1 indexed. Ma5termind wants Subway to sort the compressed string and tell him the kth character in the sorted compressed string.Since subway got speed Ma5termind asks him various such questions.
Help Subway in answering Ma5termind's question.
Input:
The first line contains the compressed string.This is followed by Q that indicates the number of questions Ma5termind shoots on Subway.Follows Q lines each line contain an integer K.
Output:
For every question output the Kth character if it exists else print -1 .
Constraints:
2 ≤ Length of Compressed String ≤ 10^4
1 ≤ Length of Final String ≤ 10^18
1 ≤ Q ≤ 10^5
1 ≤ K ≤ 10^18
Every character in the string is lowercase English letter.
Note:
The number for a character may contain leading zeroes.
SAMPLE INPUT
a2b3c2a1
4
2
5
1
8
SAMPLE OUTPUT
a
b
a
c
Explanation
The final sorted string is aaabbbcc.
|
import re
S = str(raw_input())
pairs = re.findall(r'([a-z])([0-9]+)', S)
alphabets_count = [0] * 26
for pair in pairs:
alphabets_count[ord(pair[0])-97] += int(pair[1])
for Q_I in range(int(raw_input())):
K = int(raw_input())
res = -1
for i in range(26):
if K <= alphabets_count[i]:
res = chr(i+97)
break
else:
K -= alphabets_count[i]
print res
|
Himu wants to go on a long drive with his girlfriend. There are N cities numbered from 1 to N, and every city is connected to every other city with bidirectional road. The length of a road is equal to XOR of the city numbers it is connecting. For example the length of road connecting city numbers 8 and 4 is 12. Himu wants this drive to be really long, so he will choose the road having maximum length. Help Himu find out the length of the longest road.
Input:
First line consists of T, the number of test cases.
Second line consists of N, the number of cities.
Output:
Print the answer for each test case in a new line.
Constraints:
1 ≤ T ≤ 10^5
1 ≤ N ≤ 10^9
SAMPLE INPUT
1
3
SAMPLE OUTPUT
3
Explanation
There are 3 cities.
Length of road between city number 1 & 2 = 3
Length of road between city number 2 & 3 = 1
Length of road between city number 1 & 3 = 2
So, clearly the maximum road length is 3.
|
t = int(raw_input())
while t:
a=1
n =int(raw_input())
n = n^1
while(n):
n/=2
a=a*2
a-=1
print a
t-=1
|
We have a FULL binary tree i.e. each node except leaves has two children.
The magic sum between any two leaf nodes (both possibly same) is the number obtained after adding values of all the nodes (including starting and ending nodes) in a unique path from first leaf to the later one.
Your task is to find the maximum magic sum in the binary tree.
Note: If path ends and starts at the same node, count that node only once.
Input :
First line of input contains T, the number of test cases. The first line of each test case contains N, the number of nodes in the tree. The next line contains an array V denoting values for N nodes in level order (left to right) traversal manner.
Output :
For every case output the maximum magic sum in the binary tree.
Constraints :
1 ≤ T ≤ 500
1 ≤ N ≤ 511
-10^6 ≤ V[i] ≤ 10^6
Explanation for given testcase:SAMPLE INPUT
1
7
2 4 5 8 -4 3 -6
SAMPLE OUTPUT
22
|
def tlnr(i):
global lis
if 2*i+1 > len(lis)-1: return lis[i],lis[i]
ldia=tlnr(2*i+1)
rdia=tlnr(2*i+2)
return max(ldia[0],rdia[0],ldia[1]+rdia[1]+lis[i]),max(ldia[1],rdia[1])+lis[i]
T = int(raw_input())
for _ in xrange(T):
N = int(raw_input())
lis = [int(e) for e in raw_input().split()]
print tlnr(0)[0]
|
A Nice-P sequence is defined as a sequence such that a1 x a2=1 (mod p), a2 x a3=1 (mod p) ..., an-1 x an = 1 (mod p). In addition, a1, a 2, a 3, ... an must be less than p and greater than or equal to 0. Given one element, a1, find the sum of the entire Nice-P sequence of length n. If, for any ai, where i ≥ 1, there exists no ai+1 such that ai x ai+1 = 1 (mod p), output -1.
NOTE: p IS NOT NECESSARILY A PRIME
Input:
The first line contains T, the number of test cases.
T lines follow, each containing a1, p, and n.
Output:
For each test case, output one line, the required sum.
Constraints:
1 ≤ T ≤ 10^5
1 ≤ a1 ≤ 10^5
1 ≤ n ≤ 10^9
a1 < p ≤10^9
SAMPLE INPUT
2
2 3 2
3 7 2
SAMPLE OUTPUT
4
8
Explanation
In the first test case, the P-interesting sequence will be 2, 2, which has a sum of 4. In the second test case, it will be 3, 5, which has a sum of 8.
|
#import sys
#sys.stdin = open("input.txt","r")
from fractions import gcd
def egcd(a, b):
x,y, u,v = 0,1, 1,0
while a != 0:
q, r = b//a, b%a
m, n = x-u*q, y-v*q
b,a, x,y, u,v = a,r, u,v, m,n
g = b
return g, x, y
for testCases in range(input()):
a,p,n = map(int,raw_input().split())
ans = 0
if gcd(a,p) != 1:
ans = -1
else:
res = egcd(a,p)[1]
if res < 0:
res += p
if n%2 == 1:
ans = a+(a+res)*(n/2)
else:
ans = (a+res)*(n/2)
print ans
|
You are given two circles C1 & C2 (centers , and radii are given), if area of circle-1 is A1 and that of circle-2 is A2 , you have to find whether area of union of these circle is the larger circle and area of intersection of these circle is smaller circle simultaneously , otherwise print "NOT SATISFIED".
Input
first line contains T number of test cases ,
For each test case there will be two lines,first will contain centre (x1,y1) and R1 radii of first circle ,
and second line contains centre (x2,y2) and R2 radii of second circle ,
Output
if A1 UNION A2 = A1 and A1 INTERSECTION A2 =A2 ,print "C1CC2"
if A1 UNION A2 = A2 and A1 INTERSECTION A2 =A1 ,print "C2CC1"
if A1 UNION A2 = A2(or A1) and A1 INTERSECTION A2 =A1(or A2) ,print "C2~C1"
Otherwise print "NOT SATISFIED"
Print without quotes(" ")
Constraints:
x-coordinate , y-coordinate, and radius are from 0 to 100 (integer)
SAMPLE INPUT
4
0 0 1
0 0 2
1 2 2
2 2 2
2 3 5
3 3 1
1 1 1
1 1 1
SAMPLE OUTPUT
C2CC1
NOT SATISFIED
C1CC2
C2~C1
|
import math
T = int(input())
for t in range(T):
x1,y1,r1 = map(int, raw_input().split())
x2,y2,r2 = map(int, raw_input().split())
d = math.sqrt((x1-x2)**2 + (y1-y2)**2)
if d==0 and r1==r2:
print "C2~C1"
elif d>abs(r1-r2):
print "NOT SATISFIED"
elif r1>r2:
print "C1CC2"
else:
print "C2CC1"
|
There is a mysterious temple in Mysteryland. The door of the temple is always closed.It can only be opened by a unique procedure.There are two boxes and N items outside the temple.Sherlock holmes visits the temple many times.Each time Sherlock holmes visits the temple,the number of items N outside the door of the temple is changed but each time he anyhow manages to know the cost of those N items.The door of the temple can only be opened if those "N items" are distributed in those two boxes such that the sum of cost of items in one box is equal to the sum of cost of items in other box.Sherlock holmes is trying to do such a distribution so as to open the door of the temple.you have to tell whether the door the temple can be opened or not.
INPUT
the first line contain the number of test cases i.e the number of time sherlock holmes visits the temple. Next lines contains the description of those test cases.For the first line contain number of items "N".The second line contains cost of those N items.
OUTPUT
output "YES" if the door of the temple can be opened otherwise output "NO".
Constraint:
1 ≤ testcases ≤ 10
1 ≤ N ≤ 100
1 ≤ cost ≤ 100
SAMPLE INPUT
3
5
4 3 5 5 3
4
1 2 3 4
2
1 2
SAMPLE OUTPUT
YES
YES
NO
Explanation
there are three testcases
testcase 1:the items can be distributed in the boxes as {4,3,3} ,{5,5}
so output is YES
testcase 2: the items can be distributed in the boxes as {4,1} ,{3,2}
so output is YES
testcase 3: such a distribution is not possible.
|
def isSubSetSum(sett, n, summ):
subset = []
for i in range(summ+1):
a = []
for j in range(n+1):
a.append(True)
subset.append(a)
for i in range(n):
subset[0][i] = True;
for i in range(summ):
subset[i][0] = False;
for i in range(summ):
for i in range(n):
subset[i][j] = subset[i][j-1];
if i >= sett[j-1]:
subset[i][j] = subset[i][j] or subset[i - sett[j-1]][j-1];
return subset[summ][n];
t = int(raw_input())
for i in range(t):
n = int(raw_input())
items = map(int, raw_input().split(' '))
summ = reduce(lambda x, y: x+y, items)
if (summ % 2 != 0):
print "NO"
continue
if (isSubSetSum(items, n, summ/2)):
print "YES"
else:
print "NO"
|
As predicted by the great Gods, Little Arjit has got nothing to do this summer. (Are you surprised?) But, he's not one of those people to lose hope... not so easily. He decided to work hard this summer on the two things he wants the most, as of now: "Dual degree work", and "an internship!"
So, following the signs from the universe, he makes multiple chits like the one shown below, and folds them, and puts all of them in a jar.
Now, he follows a certain algorithm to complete his planned hard work in the 60 days of vacations, he's got.
Let's say, little Arjit has c number of chits.
Every day, he picks up a chit from the jar.
If it's a normal, proper complete chit, he prefers selecting "dual degree" as his first choice.
He finishes off the work selected from the chit; tears that portion, and puts back the remaining half of the chit, back in the jar.
Let's say, if he picks a remaining half of some chit, he does that work - and so that chit's work is finished; and that chit is discarded.
Given the total number of chits made by Little Arjit, in how many ways can he finish of all his work?
Input format:
The first line contains an integer, t, denoting the number of test cases. The next t lines contain one integer, n, in every line, denoting the number of chits made by little Arjit.
Output format:
Print the number of ways he can empty the jar.
Constraints:
1 ≤ t ≤ 700
1 ≤ n ≤ 30
Obvious fact: For completing 30 chits, he'll be needing 30*2=60 days.
SAMPLE INPUT
2
1
3
SAMPLE OUTPUT
1
5
Explanation
Let's represent events happening on all those days as a string. How many different valid strings would be there that would empty the jar? Let's say that n = 3. D means dual degree. I means internships. So, there will be 5 different ways. They will be:
DDDIII
DIDDII
DIDIDI
DDIIDI
DDIDII
|
from math import factorial
t = int(raw_input())
while t > 0:
t -= 1
n = input()
print factorial(2*n)/(factorial(n)**2 * (n + 1))
|
Xsquare got bored playing with the arrays all the time. Therefore, he has decided to play with the strings. Xsquare called a string P a "double string" if string P is not empty and can be broken into two strings A and B such that A + B = P and A = B. for eg : strings like "baba" , "blabla" , "lolo" are all double strings whereas strings like "hacker" , "abc" , "earth" are not double strings at all.
Today, Xsquare has a special string S consisting of lower case English letters. He can remove as many characters ( possibly zero ) as he wants from his special string S. Xsquare wants to know , if its possible to convert his string S to a double string or not.
Help him in accomplishing this task.
Note :
Order of the characters left in the string is preserved even after deletion of some characters.
Input :
First line of input contains a single integer T denoting the number of test cases. First and the only line of each test case contains a string S denoting Xsquare's special string.
Output :
For each test case, print "Yes" if it is possible to convert the given string to a double string. Print "No" otherwise.
Constraints :
1 ≤ T ≤ 100
1 ≤ |S| ≤ 100
String |S| consists of lower case english alphabets only.
SAMPLE INPUT
5
wow
tata
a
ab
lala
SAMPLE OUTPUT
Yes
Yes
No
No
Yes
Explanation
TestCase 1 : "ww" can be obtained by removing 'o' from "wow".
TestCase 2 : "tata" is already a double string.
TestCase 3 : "a" cannot be converted to a double string.
TestCase 4 : "ab" cannot be converted to a double string.
TestCase 5 : "lala" is already a double string.
|
from collections import Counter
for _ in range(int(raw_input())):
s=Counter(raw_input())
f=0
for i in s.values():
if i>1:
f=1
break
if f:
print "Yes"
else:
print "No"
|
Snuke has X+Y balls. X of them have an integer A written on them, and the other Y of them have an integer B written on them.
Snuke will divide these balls into some number of groups. Here, every ball should be contained in exactly one group, and every group should contain one or more balls.
A group is said to be good when the sum of the integers written on the balls in that group is a multiple of an integer C. Find the maximum possible number of good groups.
Solve T test cases for each input file.
Constraints
* 1 \leq T \leq 2 \times 10^4
* 1 \leq A,X,B,Y,C \leq 10^9
* A \neq B
Input
Input is given from Standard Input in the following format. The first line is as follows:
T
Then, T test cases follow. Each test case is given in the following format:
A X B Y C
Output
For each test case, print a line containing the maximum possible number of good groups.
Example
Input
3
3 3 4 4 5
2 1 1 5 3
3 1 4 2 5
Output
2
2
0
|
#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
typedef long long ll;
inline int read(){
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9'){
if(c=='-')f=-1;
c=getchar();
}
while(c>='0'&&c<='9'){
x=(x<<1)+(x<<3)+c-'0';
c=getchar();
}
return x*f;
}
int T,A,X,B,Y,C,D;
vector<pair<int,int> > s;
int _gcd(int a,int b){
if(b==0)return a;
return _gcd(b,a%b);
}
void init(){
int g=_gcd(A,B);
A/=g,B/=g,C/=_gcd(g,C);
g=_gcd(A,C),A/=g,C/=g,Y/=g;
g=_gcd(B,C),B/=g,C/=g,X/=g;
}
void exgcd(int a,int b,int &x,int &y){
if(b==0){
x=1,y=0;
return;
}
exgcd(b,a%b,x,y);
int t=x;
x=y;
y=t-a/b*y;
}
int Inv(int a,int mod){
int x,y;
exgcd(a,mod,x,y);
return (x+mod)%mod;
}
int Get(int x){
return !x?C:(C-1LL*x*D%C)%C;
}
void Get_seg(){
D=1LL*A*Inv(B,C)%C;
s.clear();
int W=C,H=D,now=0,invD=Inv(D,C);
while("MAK AK IOI!"){
s.emplace_back(W/H,(int)(1LL*now*invD%C));
now+=W/H*H;
if(!(W%=H))break;
if(!(H%=W))H=W;
}
s.emplace_back(0,C);
}
int main(){
T=read();
while(T--){
A=read(),X=read(),B=read(),Y=read(),C=read();
init();
if(C==1){
printf("%d\n",X+Y);
continue;
}
Get_seg();
ll mx=0;
for(int i=0;i<(int)s.size()-1;++i){
int lx=s[i].second,rx=s[i+1].second;
int ly=Get(lx),ry=Get(rx);
int dx=(rx-lx)/s[i].first,dy=(ly-ry)/s[i].first;
auto check=[=](ll k) -> bool{
if(X-k*lx<0||Y-k*ry<0)return false;
int a=(X-k*lx)/dx,b=(Y-k*ry)/dy;
return a+b>=k*s[i].first;
};
ll l=0,r=X+Y+1,ans=0;
while(l<r){
ll mid=(l+r)>>1;
if(check(mid)){
ans=mid;
l=mid+1;
}
else{
r=mid;
}
}
mx=max(mx,ans);
}
printf("%lld\n",mx);
}
return 0;
}
|
Fennec is fighting with N monsters.
The health of the i-th monster is H_i.
Fennec can do the following two actions:
* Attack: Fennec chooses one monster. That monster's health will decrease by 1.
* Special Move: Fennec chooses one monster. That monster's health will become 0.
There is no way other than Attack and Special Move to decrease the monsters' health.
Fennec wins when all the monsters' healths become 0 or below.
Find the minimum number of times Fennec needs to do Attack (not counting Special Move) before winning when she can use Special Move at most K times.
Constraints
* 1 \leq N \leq 2 \times 10^5
* 0 \leq K \leq 2 \times 10^5
* 1 \leq H_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
H_1 ... H_N
Output
Print the minimum number of times Fennec needs to do Attack (not counting Special Move) before winning.
Examples
Input
3 1
4 1 5
Output
5
Input
8 9
7 9 3 2 3 8 4 6
Output
0
Input
3 0
1000000000 1000000000 1000000000
Output
3000000000
|
R = lambda: map(int, input().split())
n, k = R()
print(sum(sorted(R())[:n - k]) if k < n else 0)
|
You will be given a string S of length 3 representing the weather forecast for three days in the past.
The i-th character (1 \leq i \leq 3) of S represents the forecast for the i-th day. `S`, `C`, and `R` stand for sunny, cloudy, and rainy, respectively.
You will also be given a string T of length 3 representing the actual weather on those three days.
The i-th character (1 \leq i \leq 3) of S represents the actual weather on the i-th day. `S`, `C`, and `R` stand for sunny, cloudy, and rainy, respectively.
Print the number of days for which the forecast was correct.
Constraints
* S and T are strings of length 3 each.
* S and T consist of `S`, `C`, and `R`.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the number of days for which the forecast was correct.
Examples
Input
CSS
CSR
Output
2
Input
SSR
SSR
Output
3
Input
RRR
SSS
Output
0
|
#include<iostream>
using namespace std;
int ans;
char s[10],t[10];
int main()
{
cin>>s>>t;
for(int i=0;i<3;++i)
ans+=(s[i]==t[i]);
cout<<ans<<endl;
return 0;
}
|
Note the unusual memory limit.
For a rectangular grid where each square is painted white or black, we define its complexity as follows:
* If all the squares are black or all the squares are white, the complexity is 0.
* Otherwise, divide the grid into two subgrids by a line parallel to one of the sides of the grid, and let c_1 and c_2 be the complexities of the subgrids. There can be multiple ways to perform the division, and let m be the minimum value of \max(c_1, c_2) in those divisions. The complexity of the grid is m+1.
You are given a grid with H horizontal rows and W vertical columns where each square is painted white or black. HW characters from A_{11} to A_{HW} represent the colors of the squares. A_{ij} is `#` if the square at the i-th row from the top and the j-th column from the left is black, and A_{ij} is `.` if that square is white.
Find the complexity of the given grid.
Constraints
* 1 \leq H,W \leq 185
* A_{ij} is `#` or `.`.
Input
Input is given from Standard Input in the following format:
H W
A_{11}A_{12}...A_{1W}
:
A_{H1}A_{H2}...A_{HW}
Output
Print the complexity of the given grid.
Examples
Input
3 3
...
.##
.##
Output
2
Input
6 7
.####.#
....#.
....#.
....#.
.####.#
....##
Output
4
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
using namespace std;
#define M 187
#define P 16
int mark[M][M];
int dp[M][M][P][M]; //y1 y2 x1
int cut[M][M][M];
int H, W;
int main() {
cin >> H >> W;
for (int i = 0; i < H; i++)
{
string S;
cin >> S;
for (int j = 0; j < W; j++)
{
//if ((rand()) % 2 == 0) mark[i][j] = 0;
if (S[j] == '.') mark[i][j] = 0;
else mark[i][j] = 1;
}
}
for (int w = 1; w <= W; w++)
{
for (int y1 = 0; y1 + w <= H; y1++)
{
int y2 = y1 + w;
for (int x1 = 0; x1 < W; x1++)
{
dp[y1][x1][0][y2] = x1;
if (w <= 2) {
int flag = 0;
for (int x2 = x1; x2 < W; x2++)
{
for (int y = y1; y < y2; y++)
{
flag |= (1 << mark[y][x2]);
}
if (flag == 3) break;
else dp[y1][x1][0][y2] = x2 + 1;
}
}
else {
dp[y1][x1][0][y2] = min(dp[y1 + 1][x1][0][y2], dp[y1][x1][0][y2 - 1]);
}
}
}
}
for (int p = 1; p < P; p++)
{
for (int h = 1; h <= H; h++)
{
for (int y1 = 0; y1 + h <= H; y1++)
{
int y2 = y1 + h;
for (int x1 = 0; x1 < W; x1++)
{
//yoko
int ans = dp[y1][x1][p - 1][y2];
if (ans != W) ans = dp[y1][ans][p - 1][y2];
if (h >= 2 && dp[y1][x1][p][y2 - 1] > ans) {
int tmin = min(dp[y1][x1][p][y2 - 1], dp[y1 + 1][x1][p][y2]);
//tate
for (int y3 = y1 + 1; y3 < y2 && ans < tmin; y3++)
{
if (ans > dp[y1][x1][p - 1][y3]) break;
while (y3 < y2 - 1 && dp[y1][x1][p - 1][y3] == dp[y1][x1][p - 1][y3 + 1]) {
y3++;
}
if (ans < dp[y3][x1][p - 1][y2]) ans = max(ans, min(dp[y1][x1][p - 1][y3], dp[y3][x1][p - 1][y2]));
}
}
dp[y1][x1][p][y2] = ans;
//cout << y1 << " " << y2 << " " << x1 << " " << p << " " << ans << endl;
}
}
}
}
int ret = P;
for (int i = 0; i < P; i++)
{
if (dp[0][0][i][H] == W) {
ret = i;
break;
}
}
cout << ret << endl;
cin >> H;
}
|
There are N Reversi pieces arranged in a row. (A Reversi piece is a disc with a black side and a white side.) The state of each piece is represented by a string S of length N. If S_i=`B`, the i-th piece from the left is showing black; If S_i=`W`, the i-th piece from the left is showing white.
Consider performing the following operation:
* Choose i (1 \leq i < N) such that the i-th piece from the left is showing black and the (i+1)-th piece from the left is showing white, then flip both of those pieces. That is, the i-th piece from the left is now showing white and the (i+1)-th piece from the left is now showing black.
Find the maximum possible number of times this operation can be performed.
Constraints
* 1 \leq |S| \leq 2\times 10^5
* S_i=`B` or `W`
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum possible number of times the operation can be performed.
Examples
Input
BBW
Output
2
Input
BWBWBW
Output
6
|
#include<iostream>
#include<string>
using namespace std;
int main(){
string S;
long long cnt=0,sum=0;
cin >> S;
for(int i=0;i<S.size();i++){
if(S[i]=='B')cnt++;
else sum+=cnt;
}
cout << sum << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.