input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
A message from humans to extraterrestrial intelligence was sent through the Arecibo radio telescope in Puerto Rico on the afternoon of Saturday November l6, l974. The message consisted of l679 bits and was meant to be translated to a rectangular picture with 23 × 73 pixels. Since both 23 and 73 are prime numbers, 23 × 73 is the unique possible size of the translated rectangular picture each edge of which is longer than l pixel. Of course, there was no guarantee that the receivers would try to translate the message to a rectangular picture. Even if they would, they might put the pixels into the rectangle incorrectly. The senders of the Arecibo message were optimistic.
We are planning a similar project. Your task in the project is to find the most suitable width and height of the translated rectangular picture. The term ``most suitable'' is defined as follows. An integer m greater than 4 is given. A positive fraction a/b less than or equal to 1 is also given. The area of the picture should not be greater than m. Both of the width and the height of the translated picture should be prime numbers. The ratio of the width to the height should not be less than a/b nor greater than 1. You should maximize the area of the picture under these constraints.
In other words, you will receive an integer m and a fraction a/b . It holds that m > 4 and 0 < a/b ≤ 1 . You should find the pair of prime numbers p, q such that pq ≤ m and a/b ≤ p/q ≤ 1 , and furthermore, the product pq takes the maximum value among such pairs of two prime numbers. You should report p and q as the "most suitable" width and height of the translated picture.
Input
The input is a sequence of at most 2000 triplets of positive integers, delimited by a space character in between. Each line contains a single triplet. The sequence is followed by a triplet of zeros, 0 0 0, which indicates the end of the input and should not be treated as data to be processed.
The integers of each input triplet are the integer m, the numerator a, and the denominator b described above, in this order. You may assume 4 < m < 100000 and 1 ≤ a ≤ b ≤ 1000.
Output
The output is a sequence of pairs of positive integers. The i-th output pair corresponds to the i-th input triplet. The integers of each output pair are the width p and the height q described above, in this order.
Each output line contains a single pair. A space character is put between the integers as a delimiter. No other characters should appear in the output.
Example
Input
5 1 2
99999 999 999
1680 5 16
1970 1 1
2002 4 11
0 0 0
Output
2 2
313 313
23 73
43 43
37 53
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
vector<int> make_prime(int N){
bool p[N+1];
memset(p, true, sizeof(p));
p[0] = p[1] = false;
for(int i = 0 ; i*i < N ; i++){
if(p[i]){
for(int j = 2*i ; j < N ; j += i){
p[j] = false;
}
}
}
vector<int> ret;
for(int i = 0 ; i <= N ; i++){
if(p[i]) ret.push_back(i);
}
return ret;
}
int main(){
vector<int> prime = make_prime(100000);
int m, a, b;
while(cin >> m >> a >> b, m|a|b){
double a_b = (double)a / (double)b;
int max_p = 0;
int ans1, ans2;
for(int i = 0 ; i < prime.size() ; i++){
if(prime[i]*prime[i] > m) break;
for(int j = i ; j < prime.size() ; j++){
int M = prime[i]*prime[j];
if(M > m) break;
if( (M <= m) && (a_b <= (double)prime[i] / (double)prime[j]) ){
if(max_p <= M){
max_p = M;
ans1 = prime[i], ans2 = prime[j];
}
}
}
}
cout << ans1 << ' ' << ans2 << endl;
}
return 0;
}
|
Example
Input
4 6 5
-2 5
-2 -1
2 -1
2 5
-2 1
-2 0
0 0
0 -2
2 -2
2 1
Output
8
|
#include<bits/stdc++.h>
#define inf 10010
#define linf 1e16
#define eps (1e-8)
#define mod 1000000007
#define pi acos(-1)
#define phi (1.0+sqrt(5))/2.0
#define f first
#define s second
#define mp make_pair
#define pb push_back
#define all(a) (a).begin(),(a).end()
#define pd(a) printf("%.10f\n",(double)(a))
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define RFOR(i,a,b) for(int i=(a)-1;(b)<=i;i--)
#define equals(a,b) (fabs((a)-(b))<eps)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<int,double> pid;
typedef pair<double,int> pdi;
typedef pair<double,double> pdd;
typedef vector<int> vi;
typedef vector<pii> vpi;
const int dx[8]={1,0,-1,0,1,1,-1,-1};
const int dy[8]={0,1,0,-1,1,-1,1,-1};
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 k){ return Point(x*k,y*k);}
Point operator/(double k){ return Point(x/k,y/k);}
bool operator<(Point p)const{ return equals(x,p.x) ? y-p.y<-eps : x-p.x<-eps; }
bool operator==(Point p)const{ return fabs(x-p.x)<eps && fabs(y-p.y)<eps;}
double abs(){ return sqrt(norm());}
double norm(){ return (x*x+y*y);}
};
typedef Point Vector;
typedef vector<Point> Polygon;
class Segment{
public:
Point p1,p2;
Segment(Point p1=Point(),Point p2=Point()):p1(p1),p2(p2){}
};
typedef Segment Line;
class Circle{
public:
Point c;
double r;
Circle(Point c=Point(),double r=0.0):c(c),r(r){}
};
double norm(Vector a){ return (a.x*a.x+a.y*a.y);}
double abs(Vector a){ return sqrt(norm(a));}
double dot(Vector a,Vector b){ return (a.x*b.x+a.y*b.y);}
double cross(Vector a,Vector b){ return (a.x*b.y-a.y*b.x);}
bool isParallel(Vector a,Vector b){
return equals(cross(a,b),0.0);
}
bool isParallel(Segment s,Segment t){
return equals(cross(s.p1-s.p2,t.p1-t.p2),0.0);
}
int ccw(Point p0,Point p1,Point p2){
Vector a=p1-p0;
Vector b=p2-p0;
if(cross(a,b)>eps)return 1;
if(cross(a,b)<-eps)return -1;
if(dot(a,b)<-eps)return 2;
if(a.norm()<b.norm())return -2;
return 0;
}
bool intersect(Line L,Segment s){
return cross(L.p2-L.p1,s.p1-L.p1)*cross(L.p2-L.p1,s.p2-L.p1)<eps;
}
double getDistanceLP(Line l,Point p){
return abs(cross(l.p2-l.p1,p-l.p1)/abs(l.p2-l.p1));
}
bool iscrossLC(Line l,Circle c){
if((getDistanceLP(l,c.c)-c.r)<eps)return true;
return false;
}
Point getCrossPointLL(Line a,Line b){
double A=cross(a.p2-a.p1,b.p2-b.p1);
double B=cross(a.p2-a.p1,a.p2-b.p1);
if(abs(A)<eps || abs(B)<eps)return b.p1;
return b.p1+(b.p2-b.p1)*(B/A);
}
int contains(Polygon g,Point p){
int n=g.size();
bool x=false;
for(int i=0;i<n;i++){
Vector a=g[i]-p,b=g[(i+1)%n]-p;
if(abs(cross(a,b))<eps && dot(a,b)<eps)return 1;
if(a.y>b.y)swap(a,b);
if(a.y<eps && eps<b.y && cross(a,b)>eps)x=!x;
}
if(x)return 2;
return 0;
}
vector<pdd> cut(double a,double b,double c,double d){
vector<pdd> res;
if(d-a<eps || b-c<eps)res.pb(mp(a,b));
else if(c-a<eps && b-d<eps)res.pb(mp(linf,linf));
else if(c-a<eps && d-b<eps)res.pb(mp(d,b));
else if(a-c<eps && b-d<eps)res.pb(mp(a,c));
else {
res.pb(mp(a,c));
res.pb(mp(d,b));
}
return res;
}
int n,m,R;
Polygon a,b;
ll count(Segment s){
ll res=0;
queue<pdd> q;
q.push(mp(s.p1.y,s.p2.y));
FOR(i,0,m){
Point p1=b[i],p2=b[(i+1)%m];
vector<pdd> v;
vector<Point> vp,tmp;
double h=abs(p1.y-p2.y);
double w=abs(p1.x-p2.x);
double u=-linf,d=linf;
if(equals(w,0.0)){
if(iscrossLC(s,Circle(p1,R))){
u=max(u,p1.y+sqrt(R*R-(p1.x-s.p1.x)*(p1.x-s.p1.x)));
d=min(d,p1.y-sqrt(R*R-(p1.x-s.p1.x)*(p1.x-s.p1.x)));
}
if(iscrossLC(s,Circle(p2,R))){
u=max(u,p2.y+sqrt(R*R-(p2.x-s.p1.x)*(p2.x-s.p1.x)));
d=min(d,p2.y-sqrt(R*R-(p2.x-s.p1.x)*(p2.x-s.p1.x)));
}
if(equals(u,-linf))continue;
v.pb(mp(d,d+h));
v.pb(mp(u-h,u));
}
else {
if(iscrossLC(s,Circle(p1,R)))
u=sqrt(R*R-(p1.x-s.p1.x)*(p1.x-s.p1.x));
if(iscrossLC(s,Circle(p2,R)))
d=sqrt(R*R-(p2.x-s.p1.x)*(p2.x-s.p1.x));
if(intersect(s,Segment(p1,p2))){
if(!equals(u,-linf) && !equals(d,linf)){
v.pb(mp(p1.y+min(u,d),p1.y+R));
v.pb(mp(p1.y-R,p1.y-min(u,d)));
}
else v.pb(mp(p1.y-R,p1.y+R));
}
else {
if(!equals(u,-linf) && !equals(d,linf)){
v.pb(mp(p1.y+min(u,d),p1.y+max(u,d)));
v.pb(mp(p1.y-max(u,d),p1.y-min(u,d)));
}
else if(!equals(u,-linf))v.pb(mp(p1.y-u,p1.y+u));
else if(!equals(d,linf))v.pb(mp(p1.y-d,p1.y+d));
}
}
FOR(j,0,v.size()){
queue<pdd> nq;
while(q.size()){
pdd u=q.front();
q.pop();
vector<pdd> vpdd=cut(u.f,u.s,v[j].f,v[j].s);
FOR(k,0,vpdd.size()){
if(vpdd[k].s-vpdd[k].f<eps)continue;
if(vpdd[k].f==linf)continue;
nq.push(vpdd[k]);
}
}
while(nq.size()){
q.push(nq.front());
nq.pop();
}
}
}
while(q.size()){
pdd u=q.front();
if(u.s>eps)res+=int(u.s-eps);
else res+=int(u.s-1);
if(u.f>-eps)res-=int(u.f+1);
else res-=int(u.f+eps);
res++;
q.pop();
}
return res;
}
ll count(int X){
Line L(Point(X,0),Point(X,100));
vector<double> v;
FOR(i,0,n){
Segment s(a[i],a[(i+1)%n]);
if(isParallel(L,s))continue;
if(!intersect(L,s))continue;
Point M=getCrossPointLL(L,s);
v.pb(M.y);
}
sort(all(v));
ll res=0;
FOR(i,1,v.size()){
Point p1(X,v[i-1]),p2(X,v[i]);
if(contains(a,p1+(p2-p1)/2.0)==2)res+=count(Segment(p1,p2));
}
return res;
}
ll solve(){
ll res = 0;
FOR(i,-inf,inf)res+=count(i);
return res;
}
int main()
{
cin>>n>>m>>R;
a.resize(n);
b.resize(m);
FOR(i,0,n)cin>>a[i].x>>a[i].y;
FOR(i,0,m)cin>>b[i].x>>b[i].y;
cout<<solve()<<endl;
return 0;
}
|
Problem
There are N islands and M bridges. Numbers from 1 to N are assigned to each of the N islands. Numbers from 1 to M are also assigned to each of the M bridges.
Gaccho is currently on the first island (at time 0). Gaccho can move from the ai-th island to the bi-th island in one direction by using the i-th bridge.
However, at time 0, all the bridges were full of tide and sank into the sea. The i-th bridge will be able to cross the tide at time ci. And soon after the time ci, the tide rises again and the i-th bridge sinks again. When it sinks again, I don't know when the tide will pull and cross. So, Gaccho decided to think that such a bridge would never be crossed.
Gaccho wants to see the scenery of the 1st to N-1st islands for as long as possible, but since he is staying at the Nth island, he finally arrives at the Nth island. There must be. Also, because he keeps his parents waiting on the boat, Gacho must leave by boat and go home as soon as he arrives at the Nth island.
The time it takes for Gaccho to cross the bridge and travel around the island is very short, so you can assume it is 0. Find the maximum amount of time Gaccho can be on any of the 1st to N-1 islands. However, if you can't move to the Nth island no matter how you move, output -1 instead.
Constraints
* 2 ≤ N ≤ 105
* 1 ≤ M ≤ 2 × 105
* 1 ≤ ai <N
* 1 ≤ bi ≤ N
* 1 ≤ ci ≤ 109
* ai ≠ bi
Input
The input is given in the following format.
N M
a1 b1 c1
a2 b2 c2
...
aM bM cM
On the first line, two integers N and M are given, separated by blanks.
Three integers ai, bi, ci are given in each line i from the second line to the M + 1 line, separated by blanks.
Output
If Gaccho can move to the Nth island, it will output the maximum amount of time that Gaccho can be on any of the 1st to N-1th islands. If it cannot move to the Nth island, it prints -1 instead.
Examples
Input
3 2
1 2 10
2 3 20
Output
20
Input
4 4
1 2 27
1 3 37
2 3 47
3 1 57
Output
-1
Input
3 3
1 2 13
2 3 17
2 3 15
Output
17
Input
3 2
1 2 20
2 3 10
Output
-1
Input
3 2
1 2 10
2 3 10
Output
10
|
#include <cstdio>
#include <climits>
#include <vector>
#include <queue>
constexpr int MAX_N = 100000;
constexpr int INF = INT_MAX;
template<class T>
using vec = std::vector<T>;
struct Edge {
int to, age;
Edge (int to, int age) : to{to}, age{age} {}
};
struct State {
int c, v;
State (int c, int v) : c{c}, v{v} {}
bool operator < (const State &s) const {
return c > s.c;
}
};
int main()
{
int N, M, a, b, c;
scanf("%d %d", &N, &M);
vec<Edge> G[MAX_N];
for (int i = 0; i < M; i++) {
scanf("%d %d %d", &a, &b, &c); a--; b--;
G[a].push_back(Edge(b, c));
}
vec<int> d(MAX_N + 1, INF);
d[0] = 1;
std::priority_queue<State> pq;
pq.push(State(1, 0));
int res = -1;
while (!pq.empty()) {
State s = pq.top(); pq.pop();
if (s.v == N - 1 || d[s.v] < s.c) continue;
for (Edge &e : G[s.v]) {
if (d[s.v] > e.age) continue;
if (e.to == N - 1) {
res = std::max(res, e.age);
}
if (e.age < d[e.to]) {
d[e.to] = e.age;
pq.push(State(d[e.to], e.to));
}
}
}
printf("%d\n", res);
return 0;
}
|
You are one of ICPC participants and in charge of developing a library for multiprecision numbers and radix conversion. You have just finished writing the code, so next you have to test if it works correctly. You decided to write a simple, well-known factorial function for this purpose:
<image>
Your task is to write a program that shows the number of trailing zeros when you compute M! in base N, given N and M.
Input
The input contains multiple data sets. Each data set is described by one line in the format below:
N M
where N is a decimal number between 8 and 36 inclusive, and M is given in the string repre- sentation in base N. Exactly one white space character appears between them.
The string representation of M contains up to 12 characters in base N. In case N is greater than 10, capital letters A, B, C, ... may appear in the string representation, and they represent 10, 11, 12, ..., respectively.
The input is terminated by a line containing two zeros. You should not process this line.
Output
For each data set, output a line containing a decimal integer, which is equal to the number of trailing zeros in the string representation of M! in base N.
Example
Input
10 500
16 A
0 0
Output
124
2
|
#include<iostream>
#include<string>
#include<cmath>
#include<algorithm>
using namespace std;
int N; string M;
int p[50]; long long power[20];
inline long long div(long long k, int m) {
long long sum = 0;
while (k >= 1) {
k /= m; sum += k;
}
return sum;
}
int main() {
while (true) {
cin >> N >> M; power[0] = 1;
for (int i = 0; i < 50; i++)p[i] = 0;
for (int i = 1; i < M.size(); i++)power[i] = power[i - 1] * N;
if (N == 0)break;
long long C = 0;
for (int i = 0; i < M.size(); i++) {
int V = (char)(M[i] - '0'); if (M[i] >= 'A')V = (char)(M[i] - 'A') + 10;
C += power[M.size() - 1 - i] * V;
}
int L = N;
for (int i = 2; i <= L; i++) {
while (L%i == 0) {
L /= i; p[i]++;
}
}
long long minx = 1LL << 62;
for (int i = 2; i <= N; i++) {
if (p[i] == 0)continue;
minx = min(minx, div(C, i) / p[i]);
}
cout << minx << endl;
}
return 0;
}
|
Arthur is an innocent man who used to live on the Earth. He had lived a really commonplace life, until the day when the Earth was destroyed by aliens, who were not evil invaders but just contractors ordered to build a hyperspace bypass. In the moment when the demolition beams were shot at the Earth by them, Arthur was in front of his house and almost about to be decomposed into hydrogen, oxygen, carbon and some other atoms. However, fortunately, he survived; one of his friend Ford, who was actually an alien and had come to the Earth in the course of his trip around the universe, took him up to a spaceship just before the beam reached him.
Arthur and Ford successfully escaped, but it was only the beginning of their hardships. Soon it turned out that actually the spaceship was the contractor’s one itself, and as it can be easily imagined, they disliked humans. Therefore as soon as they found Arthur and Ford, they stopped at the nearest unexplored planet and dropped the two pity men out of the spaceship from 10 miles up above the land surface.
Again they’re in a pinch! Fortunately our hero Ford has a special item that let them safely land to the planet, known as a parachute, so they don’t worry about that. The problem is that they are just falling freely and can’t change the landing point, which may be on ground or sea. They want to know if they can land peacefully or need some swimming to the nearest coast.
Ford’s universal GPS gadget displays their expected position of landing by latitude/longitude. Also he has a guidebook that describes almost all the planets in the universe. According to it, the planet has the only one continent and hence only one sea. It has a description of the shape of the continent but, unfortunately, not in a intuitive way of graphical maps. So your task is to make a program to decide whether the point is on the land or not.
Input
N
P0 T0
.
.
.
PN TN
The first line of the input contains an integer N (3 ≤ N ≤ 1000). The second line contains two integers P0, T0 which represents the latitude and the longitude of the point where Arthur and Ford are going to land. The following N lines describe the shape of the only continent on the planet. The k-th line contains two integers Pk and Tk, which represents the latitude and the longitude of a point Vk. The continent is described as a polygon with N vertices Vk on a sphere. The coastline of it is formed by cyclically connecting consecutive points with the shortest line.
(Pk, Tk) (k = 0, 1, ...., N) satisfies -90 ≤ Pk ≤ 90, -180 ≤ Tk ≤ 180. Positive latitude means north and negative means south. Positive longitude means east and negative means west. The border of the continent is given by counterclockwise order and you can assume there is always exactly one way to connect given two consecutive points by minimum distance, and the shape of the continent is not selfcrossing. The landing point will be never on the coastline.
Output
If Arthur and Ford are going to land on the continent, print “Yes”. Otherwise “No”.
Examples
Input
4
0 0
10 10
10 -10
-10 -10
-10 10
Output
Yes
Input
4
89 0
0 0
0 90
0 180
0 -90
Output
Yes
Input
4
89 0
0 0
0 -90
0 180
0 90
Output
No
|
#include<cstdio>
#include<complex>
#include<vector>
#include<cmath>
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
typedef double Real;
typedef complex<Real> Point;
typedef complex<Real> Vector;
typedef pair<Point,Point> Segment;
typedef pair<Point,Point> Line;
typedef vector<Point> Polygon;
const Real eps=1e-9;
const Real PI=acos(-1.0);
template<class T> bool eq(T a,T b){
return abs(a-b)<eps;
}
template<class T> int sgn(T a){
if(eq(a,0.0)) return 0;
if(a>0) return 1;
return -1;
}
Real arg(Point p){
return atan2(p.imag(),p.real());
}
Real crP(Vector a,Vector b){
return (conj(a)*b).imag();
}
Point iLL(Line l1,Line l2){
Point a=l1.first,b=l1.second;
Point c=l2.first,d=l2.second;
Real num=crP(c-a,d-a);
Real den=crP(b-a,d-c);
return a+(b-a)*num/den;
}
bool onSeg(Point a,Point b,Point c){
return eq(abs(a-b),abs(a-c)+abs(b-c));
}
bool onLine(Point a,Point b,Point c){
return onSeg(a,b,c)||onSeg(b,c,a)||onSeg(c,a,b);
}
Real xs[1010],ys[1010],zs[1010];
Real theta0,phi0;
int N;
void rotate(){
for(int i=0;i<N;i++){
Point p=Point(xs[i],ys[i]);
Point coe=Point(cos(-theta0),sin(-theta0));
p*=coe;
xs[i]=p.real();
ys[i]=p.imag();
p=Point(xs[i],zs[i]);
coe=Point(cos(phi0),sin(phi0));
p*=coe;
xs[i]=p.real(),zs[i]=p.imag();
// printf("(%f,%f,%f)\n",xs[i],ys[i],zs[i]);
}
}
Point pts[1010];
Real rs[1010];
Point cs[1010];
bool isLine[1010];
void sphereMap(){
for(int i=0;i<N;i++){
Real coe=2.0/(1.0-zs[i]);
pts[i]=Point(xs[i]*coe,ys[i]*coe);
// printf("(%f,%f)\n",pts[i].real(),pts[i].imag());
}
for(int i=0;i<N;i++){
Point p=pts[i],q=pts[(i+1)%N];
Real x=-xs[i],y=-ys[i],z=-zs[i];
if(eq(1.0,z)){
isLine[i]=true;
continue;
}
Real coe=2.0/(1.0-z);
Point r=Point(x*coe,y*coe);
if(onLine(p,q,r)){
// printf("Line\n");
isLine[i]=true;
continue;
}
Vector perp=Vector(0,1);
Segment s1=Segment((p+q)/2.0,(p+q)/2.0+(q-p)*perp);
Segment s2=Segment((q+r)/2.0,(q+r)/2.0+(q-r)*perp);
cs[i]=iLL(s1,s2);
Real val=abs(cs[i]-p);
if(eq(val,abs(cs[i]-q))==false){
printf("error in finding center\n");
exit(0);
}
if(eq(val,abs(cs[i]-r))==false){
printf("error in finding center\n");
exit(0);
}
rs[i]=val;
// printf("circle (%f,%f) %f\n",cs[i].real(),cs[i].imag(),rs[i]);
}
}
Real normalize(Real ang){
while(ang<0) ang+=PI*2;
while(ang>PI*2) ang-=PI*2;
return ang;
}
Real calc(Real r,Real theta){
return r*r*(theta-sin(theta))/2.0;
}
Real getArea(int id){
Point p=pts[id],q=pts[(id+1)%N];
if(isLine[id]){
return crP(p,q)/2;
}
Real area1=crP(p,q)/2;
int s=sgn(area1);
if(s==0){
// printf("s=0\n");
return 0;
}
area1=abs(area1);
// Real angp=arg(p),angq=arg(q);
// Real theta=normalize(angp-angq);
Vector vp=p-cs[id],vq=q-cs[id];
Real angp=arg(vp),angq=arg(vq);
Real theta=normalize(angp-angq);
if(theta>PI) theta=PI*2-theta;
if(sgn(crP(-p,q-p))*sgn(crP(cs[id]-p,q-p))==-1){
theta=PI*2-theta;
}
Real area2=calc(rs[id],theta);
Real res=(area1+area2)*s;
// printf("r=%f,theta=%f,area1=%f,area2=%f,res=%f\n",rs[id],theta,area1,area2,res);
return res;
}
bool solve(){
Real area=0;
for(int i=0;i<N;i++){
Real cur=getArea(i);
area+=cur;
}
// printf("%f\n",area);
if(sgn(area)>0) return true;
else return false;
}
void input(){
scanf("%d",&N);
int p,t;
scanf("%d%d",&p,&t);
theta0=(Real)t*PI/180;
p=(p-90)*-1;
phi0=(Real)p*PI/180;
for(int i=0;i<N;i++){
int p,t;
scanf("%d%d",&p,&t);
Real theta=(Real)t*PI/180;
p=(p-90)*-1;
Real phi=(Real)p*PI/180;
xs[i]=cos(theta)*sin(phi);
ys[i]=sin(theta)*sin(phi);
zs[i]=cos(phi);
}
}
int main(){
input();
rotate();
sphereMap();
bool flg=solve();
if(flg) printf("Yes\n");
else printf("No\n");
return 0;
}
|
Equation
Identity
English text is not available in this practice contest.
In logical operations, only two types of values, T and F, are handled.
Let "-" be a unary operator (a symbol whose input represents one operation) and "*", "+", "->" be a binary operator (a symbol whose input represents two operations). "-" Is a logical negation (NOT), "*" is a logical product (AND), "+" is a logical sum (OR), and "->" is a logical inclusion (IMP) operator. The truth table of these logical operations is shown in the table below.
x | y | -x | (x * y) | (x + y) | (x-> y)
--- | --- | --- | --- | --- | ---
T | T | F | T | T | T
T | F | F | F | T | F
F | T | T | F | T | T
F | F | T | F | F | T
The logical expression has one of the following forms. X and Y are logical expressions, and binary operators must be enclosed in parentheses.
* Constant: T, F
* Variables: a, b, c, d, e, f, g, h, i, j, k
* Logical negation: -X
* AND: (X * Y)
* OR: (X + Y)
* Logical conditional: (X-> Y)
An equation is given that combines two formulas with the equal sign "=". An identity is an equation that holds regardless of the value of the variable that appears in the equation. I want to make a program that determines whether a given equation is an identity.
Input
The input consists of multiple lines, each line being a dataset. The dataset is a string consisting of T, F, a, b, c, d, e, f, g, h, i, j, k, (,), =,-, +, *,> and is blank. Does not include other characters such as. It can be assumed that the number of characters in one line is 1000 characters or less.
One dataset contains one equation. The grammar of the equation is given by the following BNF. All equations follow this syntax rule.
<equation> :: = <formula> "=" <formula>
<formula> :: = "T" | "F" |
"a" | "b" | "c" | "d" | "e" | "f" |
"g" | "h" | "i" | "j" | "k" |
"-" <formula> |
"(" <formula> "*" <formula> ")" |
"(" <formula> "+" <formula> ")" |
"(" <formula> "->" <formula> ")"
The end of the input is indicated by a line consisting only of "#", which is not a dataset.
Output
For each dataset, print "YES" if the equation is an identity, otherwise "NO" on one line. The output must not contain extra characters.
Sample Input
-(a + b) = (-a * -b)
(a-> b) = (-a + b)
((a * T) + b) = (-c + (a * -b))
Output for Sample Input
YES YES
YES YES
NO
Example
Input
Output
|
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
int INF = 1 << 28;
boolean val[];
String eq;
int p;
int MAX = 11;
void run() {
Scanner sc = new Scanner(System.in);
for(;;) {
eq = sc.next();
if( eq.equals("#") )break;
val = new boolean[MAX];
boolean yn = true;
for(int i=0;i<(1<<MAX);i++) {
p = 0;
for(int j=0;j<MAX;j++) val[j] = ((i>>j)&1) == 1;
if( !equation() ) {
yn = false;
break;
}
}
System.out.println( (yn? "YES": "NO") );
}
}
boolean equation() {
boolean l = formula();
p++;
boolean r = formula();
debug(l, r);
return !(l^r);
}
boolean formula() {
switch (eq.charAt(p)) {
case 'T': p++; return true;
case 'F': p++; return false;
case '(':
p++;
boolean l = formula();
int tmp = p++;
if( eq.charAt(p) == '>' ) { p++; tmp++;}
boolean r = formula();
p++;
if( eq.charAt(tmp) == '*' ) return mlt(l, r);
else if( eq.charAt(tmp) == '+' ) return add(l, r);
else return inc(l, r);
case '-': p++; return inv(formula());
default : p++; return val(eq.charAt(p-1));
}
}
boolean val(char x) {
debug(x);
return val[x-'a'];
}
boolean inv(boolean x) {
return !x;
}
boolean add(boolean x, boolean y) {
return x|y;
}
boolean mlt(boolean x, boolean y) {
return x&y;
}
boolean inc(boolean x, boolean y) {
return inv( mlt( x, inv(y) ) );
}
public static void main(String[] args) {
new Main().run();
}
void debug(Object... os) {
//System.err.println(Arrays.deepToString(os));
}
}
|
Problem Statement
You have just arrived in a small country. Unfortunately a huge hurricane swept across the country a few days ago.
The country is made up of $n$ islands, numbered $1$ through $n$. Many bridges connected the islands, but all the bridges were washed away by a flood. People in the islands need new bridges to travel among the islands again.
The problem is cost. The country is not very wealthy. The government has to keep spending down. They asked you, a great programmer, to calculate the minimum cost to rebuild bridges. Write a program to calculate it!
Each bridge connects two islands bidirectionally. Each island $i$ has two parameters $d_i$ and $p_i$. An island $i$ can have at most $d_i$ bridges connected. The cost to build a bridge between an island $i$ and another island $j$ is calculated by $|p_i - p_j|$. Note that it may be impossible to rebuild new bridges within given limitations although people need to travel between any pair of islands over (a sequence of) bridges.
Input
The input is a sequence of datasets. The number of datasets is less than or equal to $60$. Each dataset is formatted as follows.
> $n$
> $p_1$ $d_1$
> $p_2$ $d_2$
> :
> :
> $p_n$ $d_n$
Everything in the input is an integer. $n$ ($2 \leq n \leq 4{,}000$) on the first line indicates the number of islands. Then $n$ lines follow, which contain the parameters of the islands. $p_i$ ($1 \leq p_i \leq 10^9$) and $d_i$ ($1 \leq d_i \leq n$) denote the parameters of the island $i$.
The end of the input is indicated by a line with a single zero.
Output
For each dataset, output the minimum cost in a line if it is possible to rebuild bridges within given limitations in the dataset. Otherwise, output $-1$ in a line.
Sample Input
4
1 1
8 2
9 1
14 2
4
181 4
815 4
634 4
370 4
4
52 1
40 1
81 2
73 1
10
330 1
665 3
260 1
287 2
196 3
243 1
815 1
287 3
330 1
473 4
0
Output for the Sample Input
18
634
-1
916
Example
Input
4
1 1
8 2
9 1
14 2
4
181 4
815 4
634 4
370 4
4
52 1
40 1
81 2
73 1
10
330 1
665 3
260 1
287 2
196 3
243 1
815 1
287 3
330 1
473 4
0
Output
18
634
-1
916
|
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0; i<(int)(n); ++i)
using namespace std;
typedef pair<int, int> P;
int main(){
int n;
while(cin >> n && n > 0){
if(n == 1){
cout << 0 << endl;
continue;
}
if(n == 2) {
int p1, t1, p2, t2;
cin >> p1 >> t1 >> p2 >> t2;
cout << abs(p1 - p2) << endl;
continue;
}
vector<int> p1;
vector<int> p2;
p2.reserve(n * n);
vector<P> pv;
REP(i, n) {
int p, t;
cin >> p >> t;
if(t == 1){
p1.push_back(p);
}else{
pv.push_back(P(p, t));
}
}
sort(pv.begin(), pv.end());
REP(i, pv.size() - 1) pv[i].second --;
REP(i, pv.size() - 1) pv[i + 1].second --;
REP(i, pv.size()){
REP(_, pv[i].second){
p2.push_back(pv[i].first);
}
}
int n1 = p1.size();
int n2 = p2.size();
if(n1 > n2) {
cout << -1 << endl;
continue;
}
sort(p1.begin(), p1.end());
sort(p2.begin(), p2.end());
long long ans = *max_element(p2.begin(), p2.end()) - *min_element(p2.begin(), p2.end());
// cout << ans << endl;
// cout << "p1 : "; REP(i, p1.size()) cout << p1[i] << " "; cout << endl;
// cout << "p2 : "; REP(i, p2.size()) cout << p2[i] << " "; cout << endl;
vector<long long> dp(2 * n1, 0);
int last_base2 = -1;
for(int i1 = 0; i1 < n1; i1++){
vector<long long> next(2 * n1, LLONG_MAX);
int base2 = lower_bound(p2.begin(), p2.end(), p1[i1]) - p2.begin();
for(int di = 0; di < 2 * n1; di++){
int i2 = di - n1 + base2;
if(i2 < 0) continue;
if(i2 >= n2) break;
if(i1 == 0) {
next[di] = abs(p1[i1] - p2[i2]);
continue;
}
int lastdi = di + (base2 - last_base2) - 1;
if(lastdi < 0) continue;
long long last = (lastdi < 2 * n1 ? dp[lastdi] : dp.back());
if(last == LLONG_MAX) continue;
next[di] = last + abs(p1[i1] - p2[i2]);
// printf("i1 = %d i2 = %d di = %d base = %d lastdi = %d last = %lld next[%d] <- %lld + %lld = %lld\n", i1, i2, di, base2, lastdi, last, di, last, abs(p1[i1] - p2[i2]), next[di]);
}
for(int j = 1; j < 2 * n1; j++){
next[j] = min(next[j], next[j - 1]);
}
last_base2 = base2;
dp.swap(next);
}
cout << ans + (n1 != 0 ? dp.back() : 0) << endl;
}
return 0;
}
|
Example
Input
3
1 3 3
2
1 2
1 3
Output
5
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
class union_find {
public:
union_find(int n)
: par_(n, -1)
{}
void init(int n) {
par_.assign(n, -1);
}
int root(int x) {
return par_[x] < 0 ? x : par_[x] = root(par_[x]);
}
bool unite(int x, int y) {
x = root(x); y = root(y);
if(x == y) {
return false;
} else {
if(par_[x] < par_[y]) {
par_[x] += par_[y];
par_[y] = x;
} else {
par_[y] += par_[x];
par_[x] = y;
}
return true;
}
}
bool same(int x, int y) {
return root(x) == root(y);
}
int size(int x) {
return -par_[root(x)];
}
private:
std::vector<int> par_;
};
int main() {
int N;
cin >> N;
vector<int> c(N);
for(int i=0; i<N; ++i) {
cin >> c[i];
}
int M;
cin >> M;
union_find uf(N);
vector<vector<int>> g(N);
vector<vector<P>> neib(N);
for(int i=0; i<M; ++i) {
int a, b;
cin >> a >> b;
a--; b--;
if(c[a] > c[b]) {
g[b].push_back(a);
} else if(c[a] < c[b]) {
g[a].push_back(b);
} else {
uf.unite(a, b);
}
neib[a].push_back(make_pair(c[b], b));
neib[b].push_back(make_pair(c[a], a));
}
for(int i=0; i<N; ++i) {
if(neib[i].size() == 0) {
continue;
}
sort(neib[i].begin(), neib[i].end());
for(int j=0; j<neib[i].size()-1; ++j) {
P u = neib[i][j], v = neib[i][j+1];
if(u.first == v.first) {
uf.unite(u.second, v.second);
} else {
g[u.second].push_back(v.second);
}
}
}
vector<int> order;
vector<ll> dp(N);
for(int i=0; i<N; ++i) {
if(uf.root(i) == i) {
order.push_back(i);
dp[i] = 1;
} else {
for(auto& v : g[i]) {
g[uf.root(i)].push_back(v);
g[i].clear();
}
}
}
sort(order.begin(), order.end(), [&](int const v1, int const v2) {
return c[v1] < c[v2];
});
ll res = 0;
for(auto i : order) {
for(auto to : g[i]) {
dp[uf.root(to)] = max(dp[uf.root(to)], dp[i]+1);
}
res += dp[i] * uf.size(i);
}
cout << res << endl;
}
|
You are playing a coin puzzle. The rule of this puzzle is as follows:
There are $N$ coins on a table. The $i$-th coin is a circle with $r_i$ radius, and its center is initially placed at ($sx_i, sy_i$). Each coin also has a target position: you should move the $i$-th coin so that its center is at ($tx_i, ty_i$). You can move coins one by one and can move each coin at most once. When you move a coin, it must move from its initial position to its target position along the straight line. In addition, coins cannot collide with each other, including in the middle of moves.
The score of the puzzle is the number of the coins you move from their initial position to their target position. Your task is to write a program that determines the maximum score for a given puzzle instance.
Input
The input consists of a single test case formatted as follows.
$N$
$r_1$ $sx_1$ $sy_1$ $tx_1$ $ty_1$
:
$r_N$ $sx_N$ $sy_N$ $tx_1$ $ty_N$
The first line contains an integer $N$ ($1 \leq N \leq 16$), which is the number of coins used in the puzzle. The $i$-th line of the following $N$ lines consists of five integers: $r_i, sx_i, sy_i, tx_i,$ and $ty_i$ ($1 \leq r_i \leq 1,000, -1,000 \leq sx_i, sy_i, tx_i, ty_i \leq 1,000, (sx_i, sy_i) \ne (tx_i, ty_i)$). They describe the information of the $i$-th coin: $r_i$ is the radius of the $i$-th coin, $(sx_i, sy_i)$ is the initial position of the $i$-th coin, and $(tx_i, ty_i)$ is the target position of the $i$-th coin.
You can assume that the coins do not contact or are not overlapped with each other at the initial positions. You can also assume that the maximum score does not change even if the radius of each coin changes by $10^{-5}$.
Output
Print the maximum score of the given puzzle instance in a line.
Examples
Input
3
2 0 0 1 0
2 0 5 1 5
4 1 -10 -5 10
Output
2
Input
3
1 0 0 5 0
1 0 5 0 0
1 5 5 0 5
Output
3
Input
4
1 0 0 5 0
1 0 5 0 0
1 5 5 0 5
1 5 0 0 0
Output
0
|
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
constexpr ld eps = 1e-8;
using point = complex<ld>;
class segment {
public:
segment()
: a(point(0, 0)), b(point(0, 0))
{}
segment(point a_, point b_)
: a(a_), b(b_)
{}
point a, b;
};
class circle {
public:
circle()
: p(point(0, 0)), r(0)
{}
circle(point p_, ld r_)
: p(p_), r(r_)
{}
point p;
ld r;
};
ld dot(point const& a, point const& b) {
return std::real(std::conj(a) * b);
}
point proj(segment const& s, point const& p) {
ld t = dot(p - s.a, s.a - s.b) / std::norm(s.a - s.b);
return s.a + t * (s.a - s.b);
}
bool isis_sp(segment const& s, point const& p) {
return (std::abs(s.a - p) + std::abs(s.b - p) - std::abs(s.b - s.a) < eps);
}
ld dist_sc(segment const& s, circle const& c) {
ld res = 1e18;
res = min(res, abs(c.p - s.a));
res = min(res, abs(c.p - s.b));
auto pp = proj(s, c.p);
if(isis_sp(s, pp)) {
res = min(res, abs(c.p - pp));
}
return res;
}
int main() {
int N;
cin >> N;
vector<circle> s, t;
vector<segment> seg;
for(int i = 0; i < N; ++i) {
ld r, sx, sy, tx, ty;
cin >> r >> sx >> sy >> tx >> ty;
s.emplace_back(point(sx, sy), r);
t.emplace_back(point(tx, ty), r);
seg.emplace_back(point(sx, sy), point(tx, ty));
}
int res = 0;
vector<int> dp(1 << N);
for(int S = 0; S < (1 << N); ++S) {
if(__builtin_popcount(S) != dp[S]) {
continue;
}
for(int i = 0; i < N; ++i) {
if(S & (1 << i)) {
continue;
}
if(dp[S | (1 << i)] != 0) { // 計算済み
continue;
}
bool ok = true;
for(int j = 0; j < N; ++j) {
if(i == j) {
continue;
}
circle c;
c.r = s[j].r;
if(S & (1 << j)) {
c.p = t[j].p;
} else {
c.p = s[j].p;
}
ld dist = dist_sc(seg[i], c);
if(dist <= s[i].r + c.r + eps) {
ok = false;
break;
}
}
if(ok) {
dp[S | (1 << i)] = dp[S] + 1;
}
}
res = max(res, dp[S]);
}
cout << res << endl;
}
|
Problem
There are N sets of integers. Each of these sets is assigned a number from 1 to N. The number of elements in the i-th set is Ki, and the j-th smallest integer in the elements of the set is ai, j.
Taro decided to choose any number of sets from this. Taro, who thought it would be boring to just choose the right one, decided to choose at least three sets. In addition, we decided to select the product so that the product of "the number of elements in the union of the selected set" and "the number of elements in the intersection of the selected set" is as large as possible.
When Taro selects the optimal set, find the maximum value of the product of "the number of elements in the union of the selected set" and "the number of elements in the intersection of the selected set".
Constraints
The input satisfies the following conditions.
* All inputs are integers.
* 3 ≤ N ≤ 20,000
* 1 ≤ ai, j ≤ 22
* ai, j <ai, j + 1 (1 ≤ i ≤ N) (1 ≤ j <Ki)
Input
The input is given in the following format.
N
K1 a1,1 a1,2 ... a1, K1
K2 a2,1 a2,2 ... a2, K2
...
KN aN, 1 aN, 2 ... aN, KN
Output
Output the maximum value of the product of "the number of elements in the union of the selected set" and "the number of elements in the intersection of the selected set" when Taro chose optimally.
Examples
Input
4
1 5
2 3 5
3 3 5 7
4 3 5 7 9
Output
8
Input
5
4 1 4 5 6
4 1 7 8 9
3 1 2 3
3 1 2 3
3 1 2 3
Output
9
Input
3
2 3 4
2 2 5
2 1 6
Output
0
|
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
#define CIN_ONLY if(1)
struct cww{cww(){
CIN_ONLY{
ios::sync_with_stdio(false);cin.tie(0);
}
}}star;
#define fin "\n"
#define FOR(i,bg,ed) for(int i=(bg);i<(ed);i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
#define pb push_back
#define DEBUG if(0)
#define REC(ret, ...) std::function<ret (__VA_ARGS__)>
template <typename T>inline bool chmin(T &l,T r)
{bool a=l>r;if(a)l=r;return a;}
template <typename T>inline bool chmax(T &l,T r)
{bool a=l<r;if(a)l=r;return a;}
template <typename T>
istream& operator>>(istream &is,vector<T> &v){
for(auto &it:v)is>>it;
return is;
}
#define CNT __builtin_popcount
const int M=1<<22;
int s[M];
int id[M][3];
int main(){
int N;
cin>>N;
REP(i,M)REP(j,3)id[i][j]=-1;
REP(i,N){
int k;cin>>k;
int a=0;
REP(j,k){
int b;cin>>b;
a|=(1<<(b-1));
}
s[a]=a;
k=0;
for(;k<2&&id[a][k]!=-1;k++);
id[a][k]=i;
}
int res=0;
FOR(i,1,M+1){
int bit=M-i;
int cnt=0;
for(;cnt<3&&id[bit][cnt]!=-1;cnt++);
REP(j,22){
int nxt=bit|(1<<j);
s[bit]|=s[nxt];
REP(k,3){
if(cnt==3||id[nxt][k]==-1)break;
if(id[nxt][k]!=id[bit][0]&&id[nxt][k]!=id[bit][1]&&id[nxt][k]!=id[bit][2])
id[bit][cnt++]=id[nxt][k];
}
}
if(id[bit][2]!=-1)
chmax(res,CNT(bit)*CNT(s[bit]));
}
cout<<res<<endl;
return 0;
}
|
Find places where a R × C pattern is found within a H × W region. Print top-left coordinates (i, j) of sub-regions where the pattern found. The top-left and bottom-right coordinates of the region is (0, 0) and (H-1, W-1) respectively.
Constraints
* 1 ≤ H, W ≤ 1000
* 1 ≤ R, C ≤ 1000
* The input consists of alphabetical characters and digits
Input
In the first line, two integers H and W are given. In the following H lines, i-th lines of the region are given.
In the next line, two integers R and C are given. In the following R lines, i-th lines of the pattern are given.
Example
Input
4 5
00010
00101
00010
00100
3 2
10
01
10
Output
0 3
1 2
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<cctype>
#include<cstdio>
#include<cassert>
using namespace std;
struct AhoCorasick {
static const int ALPHABET_SIZE = 62, root=0;
int index(char ch){
if(isupper(ch))return ch-'A';
if(islower(ch))return 26+ch-'a';
if(isdigit(ch))return 52+ch-'0';
assert(false);
return -1;
}
int N; // num of node
struct Node {
int parent, link;
//int child[ALPHABET_SIZE], next[ALPHABET_SIZE];
int child[ALPHABET_SIZE], next[ALPHABET_SIZE];
char ch; //from parent
bool leaf;
Node():parent(0),link(0),ch('\0'),leaf(false){
link=-1;
fill(child,child+ALPHABET_SIZE,-1);
fill(next,next+ALPHABET_SIZE,-1);
}
};
vector<Node> nodes;
AhoCorasick(int maxNodes):N(1),nodes(maxNodes){
nodes[root].link = root;
nodes[root].parent = -1;
}
void addString(string s) {
int cur = 0, sl=s.size();
for(int i=0;i<sl;i++){
char ch = s[i];
int c = index(ch);
if(!~nodes[cur].child[c]){
nodes[N].parent = cur;
nodes[N].ch = ch;
nodes[cur].child[c] = N++;
}
cur = nodes[cur].child[c];
}
nodes[cur].leaf = true;
}
int link(int id) {
Node& node = nodes[id];
if(node.link == -1){
if(!node.parent)node.link=root;
else node.link=trans(link(node.parent),node.ch);
}
return node.link;
}
int trans(int id, char ch) {
int c = index(ch);
Node node = nodes[id];
if(!~node.next[c]){
if(~node.child[c])node.next[c]=node.child[c];
else if(!id)node.next[c]=root;
else node.next[c]=trans(link(id),ch);
}
return node.next[c];
}
};
typedef pair<int,int> pii;
vector<pii> bakerBird(const vector<string>&T, const vector<string>&pattern){
int pl=pattern.size(),tl=T.size(),pil=pattern[0].size();
AhoCorasick aho(500000);
for(int i=0;i<pl;i++)aho.addString(pattern[i]);
vector<int>acc;
for(int i=0;i<pl;i++){
int node = 0;
for(int j=0;j<pil;j++){
node = aho.trans(node, pattern[i][j]);
if(aho.nodes[node].leaf)acc.push_back(node);
}
}
const int til = T[0].size();
int td[til][tl];
for(int i=0;i<tl;i++){
int node = 0;
for(int j=0;j<til;j++){
node = aho.trans(node, T[i][j]);
td[til-j-1][i]=node;
}
}
vector<pii>res;
int tl2=acc.size(),sl=acc.size()+tl+1;
vector<int>a(acc.size()+tl+2,-1);
for(int i=0;i<til;i++){
vector<int>s=acc;
s.push_back(-1);
for(int j=0;j<til;j++)s.push_back(td[i][j]);
for(int k=0,j=-1;k<sl;a[++k]=++j)while(j>=0 && s[k]!=s[j])j=a[j];
for(int k=tl2+1;k<=sl;k++){
if(a[k]==tl2)res.push_back(pii(k-tl2*2-1,til-i-pil));
}
}
return res;
}
int main(void){
int h,w,r,c;
cin >> h >> w;
vector<string>s(h);
for(int i=0;i<h;i++){
s[i].resize(w);
for(int j=0;j<w;j++){
scanf(" %c",&s[i][j]);
}
}
cin >> r >> c;
vector<string>t(r);
for(int i=0;i<r;i++){
t[i].resize(c);
for(int j=0;j<c;j++){
scanf(" %c",&t[i][j]);
}
}
vector<pii>res=bakerBird(s,t);
sort(res.begin(),res.end());
for(int i=0;i<res.size();i++)
cout << res[i].first << " " << res[i].second << "\n";
return 0;
}
|
Write a program which reads two integers x and y, and prints them in ascending order.
Constraints
* 0 ≤ x, y ≤ 10000
* the number of datasets ≤ 3000
Input
The input consists of multiple datasets. Each dataset consists of two integers x and y separated by a single space.
The input ends with two 0 (when both x and y are zero). Your program should not process for these terminal symbols.
Output
For each dataset, print x and y in ascending order in a line. Put a single space between x and y.
Example
Input
3 2
2 2
5 3
0 0
Output
2 3
2 2
3 5
|
while 1:
x, y = map(int, raw_input().split())
if (x == 0) and (y == 0):
break
elif x > y:
x, y = y, x
print x, y
|
Problem Statement
A mountain hiker is descending from the mountain ranges. There are many mountains along his way each with it's own height. He will descend from
mountain only if the mountains' height ahead of him are Non Increasing.
You are given the height of the mountains ahead of you. Your task is to determine the minimum amount of height you have to reduce from the mountains
ahead of the hiker in order to complete his expedition.
Input
Input description.
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows
The first line of each test case contains a single integer N denoting the number of mountains ahead of him.
The second line contains N space-separated integers A1, A2, ..., AN denoting the height of the mountains.
Output
Output description.
For each test case, output a single line containing the answer.
Constraints
1 ≤ T ≤ 100
1 ≤ N ≤ 10^7
1 ≤ Ai ≤ 10^7
Example
Input:
1
5
3 2 4 1 2
Output:
3
|
import sys
T = int(raw_input())
while T > 0:
N = int(raw_input())
ans = 0
prev = None
#l = map(int, raw_input().split())
l = list(map(int,sys.stdin.readline().split()))
for i in range(N):
curr = l[i]
if i>0 and curr>prev:
ans += curr-prev
curr = prev
prev = curr
print ans
T -= 1
|
Chef is on a vacation these days, so his friend Chefza is trying to solve Chef's everyday tasks.
Today's task is to make a sweet roll. Rolls are made by a newly invented cooking machine. The machine is pretty universal - it can make lots of dishes and Chefza is thrilled about this.
To make a roll, Chefza has to set all the settings to specified integer values. There are lots of settings, each of them set to some initial value. The machine is pretty complex and there is a lot of cooking to be done today, so Chefza has decided to use only two quick ways to change the settings. In a unit of time, he can pick one setting (let's say its current value is v) and change it in one of the following ways.
If v is even, change this setting to v/2. If v is odd, change it to (v − 1)/2.
Change setting to 2 × v
The receipt is given as a list of integer values the settings should be set to. It is guaranteed that each destination setting can be represented as an integer power of 2.
Since Chefza has just changed his profession, he has a lot of other things to do. Please help him find the minimum number of operations needed to set up a particular setting of the machine. You can prove that it can be done in finite time.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The only line of each test case contains two integers A and B denoting the initial and desired values of the setting, respectively.
Output
For each test case, output a single line containing minimum number of operations Chefza has to perform in order to set up the machine.
Constraints
1 ≤ T ≤ 200
1 ≤ A ≤ 10^7
1 ≤ B ≤ 10^7, and B is an integer power of 2
Example
Input:
6
1 1
2 4
3 8
4 16
4 1
1 4
Output:
0
1
4
2
2
2
Explanation
In the first test case, you don't need to do anything.
In the second test case, you need to multiply 2 by 2 and get 4. This is done in 1 operation.
In the third test case, you need to obtain 1 from 3 and then multiply it by 2 three times to obtain 8. A total of 4 operations.
In the fourth test case, multiply 4 by 2 twice.
In the fifth test case, divide 4 by 2 twice.
In the sixth test case, multiply 1 by 2 twice.
|
test_cases = int(raw_input())
for i in range(test_cases):
AB = raw_input().split()
A = int(AB[0])
B = int(AB[1])
counter = 0
while (A != B):
if (B%A == 0):
A=A*2
counter += 1
else:
A=A/2
counter += 1
print counter
|
Chef has a rooted tree G, consisting of N vertices. Each edge of the tree has a color black or white.
Once Chef's friend Ksen offered Chef to play a game on the tree G. The game has very simple rule:
The players make moves in the game alternately.
On his move Chef deletes a single undeleted black edge. On her move Ksen deletes a single undeleted white edge.
When some edge has been deleted, all the edges that now aren't connected (directly or indirectly) to the root will be deleted too.
One who cannot move lose the game.
Chef really likes the game. The only problem is that Ksen knows the game very well. So she always plays optimally. That's why Chef has decided to choose the order of moves. Help Chef: tell him who will win the game if he moves first, and also who will win the game if Ksen moves first. Consider that Chef plays optimally too.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each testcase contains a single integer N. Then N - 1 lines follows. Each contains three integers Ui, Vi, Ci. These integers denotes the current edge of the tree: the first two numbers means the numbers of vertices connected by the edge, the last number denotes the color of the edge (zero means black, one means white). Consider all vertices of the tree G are numbered from 1 to N. The root has number 1.
Output
For each test case, output a single line containing two strings: the name of the winner if Chef moves first, and the name of the winner if Chef moves second.
Constraints
1 ≤ T ≤ 1000
1 ≤ N ≤ 100000
1 ≤ Ui, Vi ≤ N
0 ≤ Ci ≤ 1
It's guaranteed that the sum of N values for all tests doesn't exceed 100000.
Example
Input:
5
1
2
1 2 0
2
1 2 1
3
1 2 0
1 3 1
3
1 2 0
2 3 1
Output:
Ksen Chef
Chef Chef
Ksen Ksen
Ksen Chef
Chef Chef
|
import random
class Ordinal(object):
def __init__(self, v, r = 0):
while (v&1)==0 and r > 0:
v >>= 1
r -= 1
self.v, self.r = v, r
def __repr__(self):
return '%d / 2^%d' % (self.v, self.r)
def __add__(self, o):
if isinstance(o, int):
o = Ordinal(o)
if o.r < self.r:
return Ordinal(self.v+(o.v<<(self.r-o.r)), self.r)
else:
return Ordinal(o.v+(self.v<<(o.r-self.r)), o.r)
def __eq__(self, o):
return self.r == o.r and self.v == o.v
def sign(self):
if self.v > 0:
return 1
elif self.v < 0:
return -1
else:
return 0
def colon(self, o):
if o == 1:
# return (1:x)
if self.v >= 0:
return Ordinal(self.v+(1L<<self.r), self.r)
else:
k = 1-(self.v >> self.r)
return Ordinal(self.v+(k<<self.r), self.r+(k-1))
elif o == -1:
# return (-1:x)
if self.v <= 0:
return Ordinal(self.v-(1L<<self.r), self.r)
else:
k = 1-((-self.v) >> self.r)
return Ordinal(self.v-(k<<self.r), self.r+(k-1))
else:
raise ValueError
@staticmethod
def stick_test(s):
r1 = Ordinal(0)
for x in s:
if r1.r == 0 and r1.v * x >= 0:
r1 += x
else:
r1 += Ordinal(x, r1.r+1)
r2 = Ordinal(0)
for x in s[::-1]:
r2 = r2.colon(x)
if not (r1 == r2):
print str(s) + ': exp ' + str(r1) + ', got ' + str(r2)
raise ValueError
def HackenbushTree(n, e):
ve = [list() for _ in range(n+1)]
for x in e:
ve[x[0]].append((x[1], x[2]))
ve[x[1]].append((x[0], x[2]))
q = [[1, 0, None, None]]
res = None
while len(q):
x, cx, px, v = q.pop()
if v is None:
cur = [x, cx, px, Ordinal(0)]
q.append(cur)
for y, cy in ve[x]:
if px is None or y != px[0]:
q.append([y, cy, cur, None])
else:
if px is None:
res = v
else:
px[3] += v.colon(cx)
return res.sign()
def main():
t = int(raw_input())
for _ in range(t):
n = int(raw_input())
e = []
for _ in range(n-1):
u, v, c = map(int, raw_input().split())
e.append((u, v, 1-2*c))
res = HackenbushTree(n, e)
if res > 0:
print 'Chef Chef'
elif res < 0:
print 'Ksen Ksen'
else:
print 'Ksen Chef'
if __name__ == '__main__':
main()
|
Chef Ciel wants to put a fancy neon signboard over the entrance of her restaurant. She has not enough money to buy the new one so she bought some old neon signboard through the internet. Ciel was quite disappointed when she received her order - some of its letters were broken. But she realized that this is even better - she could replace each broken letter by any letter she wants. So she decided to do such a replacement that the resulting signboard will contain the word "CHEF" as many times as possible.
We can model the signboard as a string S having capital letters from 'A' to 'Z', inclusive, and question marks '?'. Letters in the string indicate the intact letters at the signboard, while question marks indicate broken letters. So Ciel will replace each question mark with some capital letter and her goal is to get the string that contains as many substrings equal to "CHEF" as possible. If there exist several such strings, she will choose the lexicographically smallest one.
Note 1. The string S = S1...SN has the substring "CHEF" if for some i we have SiSi+1Si+2Si+3 = "CHEF". The number of times "CHEF" is the substring of S is the number of those i for which SiSi+1Si+2Si+3 = "CHEF".
Note 2. The string A = A1...AN is called lexicographically smaller than the string B = B1...BN if there exists K from 1 to N, inclusive, such that Ai = Bi for i = 1, ..., K-1, and AK < BK. In particular, A is lexicographically smaller than B if A1 < B1. We compare capital letters by their positions in the English alphabet. So 'A' is the smallest letter, 'B' is the second smallest letter, ..., 'Z' is the largest letter.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows. The only line of each test case contains a string S.
Output
For each test case, output a single line containing the content of the signboard Chef Ciel will come up with. That is you should output the lexicographically smallest string that could be obtained from the input string by replacing all its question marks by some capital letters and having as many substrings equal to "CHEF" as possible.
Constraints
1 ≤ T ≤ 2013
1 ≤ length of S ≤ 2013
Each character in S is either a capital letter from 'A' to 'Z', inclusive, or the question mark '?'.
Example
Input:
5
????CIELIS???E?
????CIELISOUR???F
T?KEITE?SY
????????
???C???
Output:
CHEFCIELISACHEF
CHEFCIELISOURCHEF
TAKEITEASY
CHEFCHEF
AAACHEF
Explanation
Example Case 1. Here the resulting string can have at most 2 substrings equal to "CHEF". For example, some possible such strings are:
CHEFCIELISACHEF
CHEFCIELISQCHEF
CHEFCIELISZCHEF
However, lexicographically smallest one is the first one.
Example Case 3. Here the resulting string cannot have "CHEF" as its substring. Therefore, you must simply output the lexicographically smallest string that can be obtained from the given one by replacing question marks with capital letters.
|
for t in xrange(int(raw_input())):
line = list(raw_input())
length = len(line)
x = length-1
while x > 2:
tmp = [line[x], line[x-1], line[x-2], line[x-3]]
if (
(tmp[0] == '?' or tmp[0] == 'F') and
(tmp[1] == '?' or tmp[1] == 'E') and
(tmp[2] == '?' or tmp[2] == 'H') and
(tmp[3] == '?' or tmp[3] == 'C')
):
line[x] = 'F'
line[x-1] = 'E'
line[x-2] = 'H'
line[x-3] = 'C'
x -= 3
if line[x] == '?':
line[x] = 'A'
x -= 1
try:
if line[0] == '?':
line[0] = 'A'
if line[1] == '?':
line[1] = 'A'
if line[2] == '?':
line[2] = 'A'
except:
pass
print ''.join(line)
|
There is a war going on between two countries and the enemy of your country depends heavily on the transportation of Weapons between two strategic points A and B. Point A and point B along with other points (C,D, etc... ) are connected by a network of roads. Disrupting all traffic between points A and B will give your country sufficient time to gather valuable resources. Since your country has only one bomb left you can only destroy one road. Your Mission should you choose to accept it is to identify all roads that may be destroyed in order to restrict all traffic between the points A and B. The Enemy has nearly destroyed us and hence if we are to win this war then finding that road is critical.
Input
In the input each point is identified by a single upper-case alphabet ( maximum of 26 ).Each line of input identifies a pair of points connected by a road. Input ends with the line containing the string "END" (quotes for clarity). All roads are bi-directional and more over there is at most one road between any two points.
Output
Output all roads such that blowing any one of them will halt all traffic between points A and B. Note that the roads should be sorted according to order in which they are listed in the input (Check sample test case).
If no such road exists then output should be "Too Bad, We Lose" (quotes for clarity).
Example
Input:
AC
AD
AE
CE
CF
ED
GF
BG
HB
GH
END
Output:
CF
GF
|
#!/usr/bin/env python
MAXN = 26
parent = [0] * MAXN
rank = [0] * MAXN
def UF_MakeSet():
for x in xrange(MAXN):
parent[x] = x
rank[x] = 0
def UF_Union(x, y):
xRoot = UF_Find(x)
yRoot = UF_Find(y)
if xRoot == yRoot:
return
if rank[xRoot] < rank[yRoot]:
parent[xRoot] = yRoot
elif rank[xRoot] > rank[yRoot]:
parent[yRoot] = xRoot
else:
parent[yRoot] = xRoot
rank[xRoot] += 1
def UF_Find(x):
if parent[x] != x:
parent[x] = UF_Find(parent[x])
return parent[x]
def isABconnected(G, e):
UF_MakeSet()
for i in xrange(len(G)):
if i == e: continue
x = ord(G[i][0])-ord('A')
y = ord(G[i][1])-ord('A')
UF_Union(x, y)
return UF_Find(0) == UF_Find(1)
def main():
G = []
while True:
R = raw_input().strip()
if R == 'END': break
G += [R]
N = 0
for i in xrange(len(G)):
if not isABconnected(G, i):
print G[i]
N += 1
if not N:
print 'Too Bad, We Lose'
main()
|
The game of billiards involves two players knocking 3 balls around
on a green baize table. Well, there is more to it, but for our
purposes this is sufficient.
The game consists of several rounds and in each round both players
obtain a score, based on how well they played. Once all the rounds
have been played, the total score of each player is determined by
adding up the scores in all the rounds and the player with the higher
total score is declared the winner.
The Siruseri Sports Club organises an annual billiards game where
the top two players of Siruseri play against each other. The Manager
of Siruseri Sports Club decided to add his own twist to the game by
changing the rules for determining the winner. In his version, at the
end of each round the leader and her current lead are calculated. Once
all the rounds are over the player who had the maximum lead at the
end of any round in the game is declared the winner.
Consider the following score sheet for a game with 5 rounds:
Round Player 1 Player 2
1 140 82
2 89 134
3 90 110
4 112 106
5 88 90
The total scores of both players, the leader and the lead after
each round for this game is given below:
Round Player 1 Player 2 Leader Lead
1 140 82 Player 1 58
2 229 216 Player 1 13
3 319 326 Player 2 7
4 431 432 Player 2 1
5 519 522 Player 2 3
The winner of this game is Player 1 as he had the maximum lead (58
at the end of round 1) during the game.
Your task is to help the Manager find the winner and the winning
lead. You may assume that the scores will be such that there will
always be a single winner. That is, there are no ties.
Input
The first line of the input will contain a single integer N (N
≤ 10000) indicating the number of rounds in the game. Lines
2,3,...,N+1 describe the scores of the two players in the N rounds.
Line i+1 contains two integer Si and Ti, the scores of the Player 1
and 2 respectively, in round i. You may assume that 1 ≤ Si ≤
1000 and 1 ≤ Ti ≤ 1000.
Output
Your output must consist of a single line containing two integers
W and L, where W is 1 or 2 and indicates the winner and L is the
maximum lead attained by the winner.
Example
Input:
5
140 82
89 134
90 110
112 106
88 90
Output:
1 58
|
t = int(raw_input())
scr1=0
scr2=0
ma = 0
flag = 0
for i in xrange(t):
s1,s2 = map(int,raw_input().split(' '))
scr1+=s1
scr2+=s2
if(scr1>scr2):
temp = scr1-scr2
if(temp > ma):
ma = temp
flag = 1
else:
temp = scr2-scr1
if(temp > ma):
ma = temp
flag = 2
print flag,ma
|
Welcome to Innopolis city. Throughout the whole year, Innopolis citizens suffer from everlasting city construction.
From the window in your room, you see the sequence of n hills, where i-th of them has height ai. The Innopolis administration wants to build some houses on the hills. However, for the sake of city appearance, a house can be only built on the hill, which is strictly higher than neighbouring hills (if they are present). For example, if the sequence of heights is 5, 4, 6, 2, then houses could be built on hills with heights 5 and 6 only.
The Innopolis administration has an excavator, that can decrease the height of an arbitrary hill by one in one hour. The excavator can only work on one hill at a time. It is allowed to decrease hills up to zero height, or even to negative values. Increasing height of any hill is impossible. The city administration wants to build k houses, so there must be at least k hills that satisfy the condition above. What is the minimum time required to adjust the hills to achieve the administration's plan?
However, the exact value of k is not yet determined, so could you please calculate answers for all k in range <image>? Here <image> denotes n divided by two, rounded up.
Input
The first line of input contains the only integer n (1 ≤ n ≤ 5000)—the number of the hills in the sequence.
Second line contains n integers ai (1 ≤ ai ≤ 100 000)—the heights of the hills in the sequence.
Output
Print exactly <image> numbers separated by spaces. The i-th printed number should be equal to the minimum number of hours required to level hills so it becomes possible to build i houses.
Examples
Input
5
1 1 1 1 1
Output
1 2 2
Input
3
1 2 3
Output
0 2
Input
5
1 2 3 2 2
Output
0 1 3
Note
In the first example, to get at least one hill suitable for construction, one can decrease the second hill by one in one hour, then the sequence of heights becomes 1, 0, 1, 1, 1 and the first hill becomes suitable for construction.
In the first example, to get at least two or at least three suitable hills, one can decrease the second and the fourth hills, then the sequence of heights becomes 1, 0, 1, 0, 1, and hills 1, 3, 5 become suitable for construction.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
const int INF = 0x3f3f3f3f;
int dp[maxn][3];
int high[maxn];
int cal1(int i) {
int ans = 0;
if (high[i] <= high[i - 1]) ans += (high[i - 1] - high[i] + 1);
if (high[i] <= high[i + 1]) ans += (high[i + 1] - high[i] + 1);
return ans;
}
int cal2(int i) {
int ans = 0;
int tmp = high[i - 1];
if (i >= 2 && high[i - 2] <= high[i - 1]) tmp = high[i - 2] - 1;
if (high[i] <= tmp) ans += (tmp - high[i] + 1);
if (high[i] <= high[i + 1]) ans += (high[i + 1] - high[i] + 1);
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &high[i]);
high[0] = -INF;
high[n + 1] = -INF;
int m = ceil(n / 2.0);
int a, b, c;
memset(dp, INF, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = m; j >= 1; j--) {
a = dp[j][0];
b = dp[j][1];
c = dp[j][2];
dp[j][0] = min(a, c);
dp[j][1] = min(dp[j - 1][0] + cal1(i), dp[j - 1][2] + cal2(i));
dp[j][2] = b;
}
}
for (int i = 1; i <= m; i++)
cout << min(min(dp[i][0], dp[i][1]), dp[i][2]) << " ";
cout << endl;
return 0;
}
|
Two players A and B have a list of n integers each. They both want to maximize the subtraction between their score and their opponent's score.
In one turn, a player can either add to his score any element from his list (assuming his list is not empty), the element is removed from the list afterward. Or remove an element from his opponent's list (assuming his opponent's list is not empty).
Note, that in case there are equal elements in the list only one of them will be affected in the operations above. For example, if there are elements \{1, 2, 2, 3\} in a list and you decided to choose 2 for the next turn, only a single instance of 2 will be deleted (and added to the score, if necessary).
The player A starts the game and the game stops when both lists are empty. Find the difference between A's score and B's score at the end of the game, if both of the players are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves. In this problem, it means that each player, each time makes a move, which maximizes the final difference between his score and his opponent's score, knowing that the opponent is doing the same.
Input
The first line of input contains an integer n (1 ≤ n ≤ 100 000) — the sizes of the list.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^6), describing the list of the player A, who starts the game.
The third line contains n integers b_i (1 ≤ b_i ≤ 10^6), describing the list of the player B.
Output
Output the difference between A's score and B's score (A-B) if both of them are playing optimally.
Examples
Input
2
1 4
5 1
Output
0
Input
3
100 100 100
100 100 100
Output
0
Input
2
2 1
5 6
Output
-3
Note
In the first example, the game could have gone as follows:
* A removes 5 from B's list.
* B removes 4 from A's list.
* A takes his 1.
* B takes his 1.
Hence, A's score is 1, B's score is 1 and difference is 0.
There is also another optimal way of playing:
* A removes 5 from B's list.
* B removes 4 from A's list.
* A removes 1 from B's list.
* B removes 1 from A's list.
The difference in the scores is still 0.
In the second example, irrespective of the moves the players make, they will end up with the same number of numbers added to their score, so the difference will be 0.
|
import java.util.Collections;
import java.util.HashMap;
import java.util.PriorityQueue;
import java.util.Scanner;
/* Name of the class has to be "Main" only if the class is public. */
public class template {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
PriorityQueue<Long> q1 = new PriorityQueue<>(20,Collections.reverseOrder());
PriorityQueue<Long> q2 = new PriorityQueue<>(20,Collections.reverseOrder());
for(int i=0;i<n;i++) {
q1.add(s.nextLong());
}
for(int i=0;i<n;i++) {
q2.add(s.nextLong());
}
long sum1=0,sum2=0;
while(!q1.isEmpty() || !q2.isEmpty()) {
long a=0,b=0;
if(!q1.isEmpty())
a = q1.peek();
if(!q2.isEmpty())
b = q2.peek();
if(a>b) {
sum1+=a;
q1.poll();
}
else {
q2.poll();
}
a=0;
b=0;
if(!q1.isEmpty())
a = q1.peek();
if(!q2.isEmpty())
b = q2.peek();
if(b>a) {
sum2+=b;
q2.poll();
}
else {
q1.poll();
}
}
System.out.println(sum1-sum2);
}
}
|
There is a strip with an infinite number of cells. Cells are numbered starting with 0. Initially the cell i contains a ball with the number i.
There are n pockets located at cells a_1, …, a_n. Each cell contains at most one pocket.
Filtering is the following sequence of operations:
* All pockets at cells a_1, …, a_n open simultaneously, which makes balls currently located at those cells disappear. After the balls disappear, the pockets close again.
* For each cell i from 0 to ∞, if the cell i contains a ball, we move that ball to the free cell j with the lowest number. If there is no free cell j < i, the ball stays at the cell i.
Note that after each filtering operation each cell will still contain exactly one ball.
For example, let the cells 1, 3 and 4 contain pockets. The initial configuration of balls is shown below (underscores display the cells with pockets):
0 1 2 3 4 5 6 7 8 9 ...
After opening and closing the pockets, balls 1, 3 and 4 disappear:
0 2 5 6 7 8 9 ...
After moving all the balls to the left, the configuration looks like this:
0 2 5 6 7 8 9 10 11 12 ...
Another filtering repetition results in the following:
0 5 8 9 10 11 12 13 14 15 ...
You have to answer m questions. The i-th of these questions is "what is the number of the ball located at the cell x_i after k_i repetitions of the filtering operation?"
Input
The first line contains two integers n and m — the number of pockets and questions respectively (1 ≤ n, m ≤ 10^5).
The following line contains n integers a_1, …, a_n — the numbers of cells containing pockets (0 ≤ a_1 < … < a_n ≤ 10^9).
The following m lines describe questions. The i-th of these lines contains two integers x_i and k_i (0 ≤ x_i, k_i ≤ 10^9).
Output
Print m numbers — answers to the questions, in the same order as given in the input.
Example
Input
3 15
1 3 4
0 0
1 0
2 0
3 0
4 0
0 1
1 1
2 1
3 1
4 1
0 2
1 2
2 2
3 2
4 2
Output
0
1
2
3
4
0
2
5
6
7
0
5
8
9
10
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100000;
int m, n;
int a[Maxn + 5], p[Maxn + 5];
int x[Maxn + 5], k[Maxn + 5];
int e_pos[Maxn + 5], steps[Maxn + 5];
int Root[Maxn + 5];
struct Segment_Node {
int lson, rson;
int val;
} seg[Maxn * 25 + 5];
int id_tot;
void build(int &root, int left = 1, int right = n) {
root = ++id_tot;
seg[root].val = right - left + 1;
if (left == right) {
return;
}
int mid = (left + right) >> 1;
build(seg[root].lson, left, mid);
build(seg[root].rson, mid + 1, right);
}
int find_kth(int root, int k, int left = 1, int right = n) {
if (left == right) {
return left;
}
int mid = (left + right) >> 1;
if (k <= seg[seg[root].lson].val) {
return find_kth(seg[root].lson, k, left, mid);
}
return find_kth(seg[root].rson, k - seg[seg[root].lson].val, mid + 1, right);
}
void update(int &root, int last, int x, int a, int left = 1, int right = n) {
root = ++id_tot;
seg[root] = seg[last];
seg[root].val += a;
if (left == right) {
return;
}
int mid = (left + right) >> 1;
if (x <= mid) {
update(seg[root].lson, seg[last].lson, x, a, left, mid);
} else {
update(seg[root].rson, seg[last].rson, x, a, mid + 1, right);
}
}
int query(int root, int x, int left = 1, int right = n) {
if (left == right) {
return seg[root].val;
}
int mid = (left + right) >> 1;
if (x <= mid) {
return query(seg[root].lson, x, left, mid);
}
return seg[seg[root].lson].val + query(seg[root].rson, x, mid + 1, right);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
e_pos[0] = a[1] - 1;
steps[0] = 0;
for (int i = 1; i < n; i++) {
int delta = (a[i + 1] - e_pos[i - 1] - 1) / i;
e_pos[i] = e_pos[i - 1] + i * delta;
steps[i] = steps[i - 1] + delta;
}
for (int i = 2; i <= n; i++) {
p[i] = (p[i - 1] + a[i] - a[i - 1]) % (i - 1);
}
build(Root[n]);
for (int i = n; i > 0; i--) {
p[i] = find_kth(Root[i], p[i] + 1);
update(Root[i - 1], Root[i], p[i], -1);
}
for (int t = 1; t <= m; t++) {
int x, k;
scanf("%d%d", &x, &k);
if (x < a[1]) {
printf("%d\n", x);
continue;
}
int bel = lower_bound(e_pos + 1, e_pos + n, x) - e_pos;
k += steps[bel - 1] + (x - e_pos[bel - 1] - 1) / bel + 1;
int ord = (x - e_pos[bel - 1] - 1) % bel + 1;
ord = find_kth(Root[bel], ord);
bel = lower_bound(steps + 1, steps + n, k) - steps;
printf("%lld\n", e_pos[bel - 1] + 1ll * (k - steps[bel - 1] - 1) * bel +
query(Root[bel], ord));
}
return 0;
}
|
You are given array a of length n. You can choose one segment [l, r] (1 ≤ l ≤ r ≤ n) and integer value k (positive, negative or even zero) and change a_l, a_{l + 1}, ..., a_r by k each (i.e. a_i := a_i + k for each l ≤ i ≤ r).
What is the maximum possible number of elements with value c that can be obtained after one such operation?
Input
The first line contains two integers n and c (1 ≤ n ≤ 5 ⋅ 10^5, 1 ≤ c ≤ 5 ⋅ 10^5) — the length of array and the value c to obtain.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 5 ⋅ 10^5) — array a.
Output
Print one integer — the maximum possible number of elements with value c which can be obtained after performing operation described above.
Examples
Input
6 9
9 9 9 9 9 9
Output
6
Input
3 2
6 2 6
Output
2
Note
In the first example we can choose any segment and k = 0. The array will stay same.
In the second example we can choose segment [1, 3] and k = -4. The array will become [2, -2, 2].
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void pr(vector<T> &v) {
for (int i = 0; i < (int)(v).size(); i++) cout << v[i] << " ";
cout << endl;
}
template <typename T>
void pr(vector<vector<T>> &v) {
for (int i = 0; i < (int)(v).size(); i++) {
pr(v[i]);
}
}
template <typename T>
void re(T &first) {
cin >> first;
}
template <typename T>
void re(vector<T> &a) {
for (int i = 0; i < (int)(a).size(); i++) re(a[i]);
}
template <class Arg, class... Args>
void re(Arg &first, Args &...rest) {
re(first);
re(rest...);
}
template <typename T>
void pr(T first) {
cout << first << endl;
}
template <class Arg, class... Args>
void pr(const Arg &first, const Args &...rest) {
cout << first << " ";
pr(rest...);
cout << endl;
}
void ps() { cout << endl; }
template <class T, class... Ts>
void ps(const T &t, const Ts &...ts) {
cout << t;
if (sizeof...(ts)) cout << " ";
ps(ts...);
}
vector<int> pre;
int cnt(int l, int r) { return pre[r + 1] - pre[l]; }
void solve() {
int n, c;
re(n, c);
vector<int> a(n);
re(a);
pre.resize(n + 1);
pre[0] = 0;
for (int i = 0; i < n; i++) {
pre[i + 1] = pre[i] + ((a[i] == c) ? 1 : 0);
}
vector<vector<int>> ind(5e5 + 1);
for (int i = 0; i < n; i++) {
ind[a[i]].push_back(i);
}
int mx = 0;
for (int i = 1; i < (int)(ind).size(); i++) {
int m = (int)(ind[i]).size();
if (!m || i == c) continue;
int cur = 1;
mx = max(mx, cur);
for (int j = 1; j < (int)(ind[i]).size(); j++) {
cur -= cnt(ind[i][j - 1], ind[i][j]) - 1;
if (cur <= 0) {
cur = 1;
}
mx = max(mx, cur);
}
}
pr(cnt(0, n - 1) + mx);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int tt = 0; tt < t; tt++) {
solve();
}
}
|
You are given an array a_1, a_2, ..., a_n of integer numbers.
Your task is to divide the array into the maximum number of segments in such a way that:
* each element is contained in exactly one segment;
* each segment contains at least one element;
* there doesn't exist a non-empty subset of segments such that bitwise XOR of the numbers from them is equal to 0.
Print the maximum number of segments the array can be divided into. Print -1 if no suitable division exists.
Input
The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the size of the array.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 10^9).
Output
Print the maximum number of segments the array can be divided into while following the given constraints. Print -1 if no suitable division exists.
Examples
Input
4
5 5 7 2
Output
2
Input
3
1 2 3
Output
-1
Input
3
3 1 10
Output
3
Note
In the first example 2 is the maximum number. If you divide the array into \{[5], [5, 7, 2]\}, the XOR value of the subset of only the second segment is 5 ⊕ 7 ⊕ 2 = 0. \{[5, 5], [7, 2]\} has the value of the subset of only the first segment being 5 ⊕ 5 = 0. However, \{[5, 5, 7], [2]\} will lead to subsets \{[5, 5, 7]\} of XOR 7, \{[2]\} of XOR 2 and \{[5, 5, 7], [2]\} of XOR 5 ⊕ 5 ⊕ 7 ⊕ 2 = 5.
Let's take a look at some division on 3 segments — \{[5], [5, 7], [2]\}. It will produce subsets:
* \{[5]\}, XOR 5;
* \{[5, 7]\}, XOR 2;
* \{[5], [5, 7]\}, XOR 7;
* \{[2]\}, XOR 2;
* \{[5], [2]\}, XOR 7;
* \{[5, 7], [2]\}, XOR 0;
* \{[5], [5, 7], [2]\}, XOR 5;
As you can see, subset \{[5, 7], [2]\} has its XOR equal to 0, which is unacceptable. You can check that for other divisions of size 3 or 4, non-empty subset with 0 XOR always exists.
The second example has no suitable divisions.
The third example array can be divided into \{[3], [1], [10]\}. No subset of these segments has its XOR equal to 0.
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int n, x, everything = 0;
vector<int> basis;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
cin >> n;
while (n--) {
cin >> x;
everything ^= x;
for (auto& i : basis) x = min(x, x ^ i);
if (x) basis.push_back(x);
}
cout << (everything ? (int)basis.size() : -1);
}
|
Little Petya loves training spiders. Petya has a board n × m in size. Each cell of the board initially has a spider sitting on it. After one second Petya chooses a certain action for each spider, and all of them humbly perform its commands. There are 5 possible commands: to stay idle or to move from current cell to some of the four side-neighboring cells (that is, one command for each of the four possible directions). Petya gives the commands so that no spider leaves the field. It is allowed for spiders to pass through each other when they crawl towards each other in opposite directions. All spiders crawl simultaneously and several spiders may end up in one cell. Petya wants to know the maximum possible number of spider-free cells after one second.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 40, n·m ≤ 40) — the board sizes.
Output
In the first line print the maximum number of cells without spiders.
Examples
Input
1 1
Output
0
Input
2 3
Output
4
Note
In the first sample the only possible answer is:
s
In the second sample one of the possible solutions is:
rdl
rul
s denotes command "stay idle", l, r, d, u denote commands "crawl left", "crawl right", "crawl down", "crawl up", correspondingly.
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dp[45][64][64];
int ans;
bool get_bit(int a, int n) { return (a >> n) & 1; }
int set_bit(int a, int n) { return a | (1 << n); }
int reset_bit(int a, int n) { return a & ~(1 << n); }
int main() {
cin >> n >> m;
if (m > n) swap(n, m);
for (int i = 0; i <= n; i++) {
for (int j = 0; j < (1 << m); j++) {
for (int k = 0; k < (1 << m); k++) {
dp[i][j][k] = -1000;
}
}
}
dp[0][0][(1 << m) - 1] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m); j++) {
for (int k = 0; k < (1 << m); k++) {
for (int l = 0; l < (1 << m); l++) {
int s = j | l;
int cnt = 0;
int ns = (1 << m) - 1;
int nr = (1 << m) - 1 - s;
for (int i = 0; i < m; i++) {
if (!get_bit(s, i)) {
cnt++;
}
}
if (m == 1) {
if (get_bit(s, 0)) {
ns = reset_bit(ns, 0);
}
} else {
if (get_bit(s, 0)) {
ns = reset_bit(ns, 0);
ns = reset_bit(ns, 1);
}
if (get_bit(s, m - 1)) {
ns = reset_bit(ns, m - 1);
ns = reset_bit(ns, m - 2);
}
for (int i = 1; i < m - 1; i++) {
if (get_bit(s, i)) {
ns = reset_bit(ns, i - 1);
ns = reset_bit(ns, i);
ns = reset_bit(ns, i + 1);
}
}
}
dp[i][ns & k][nr] = max(dp[i][ns & k][nr], dp[i - 1][j][k] + cnt);
}
}
}
}
for (int i = 0; i < (1 << m); i++) ans = max(ans, dp[n][0][i]);
cout << ans;
return 0;
}
|
Welcome to Codeforces Stock Exchange! We're pretty limited now as we currently allow trading on one stock, Codeforces Ltd. We hope you'll still be able to make profit from the market!
In the morning, there are n opportunities to buy shares. The i-th of them allows to buy as many shares as you want, each at the price of s_i bourles.
In the evening, there are m opportunities to sell shares. The i-th of them allows to sell as many shares as you want, each at the price of b_i bourles. You can't sell more shares than you have.
It's morning now and you possess r bourles and no shares.
What is the maximum number of bourles you can hold after the evening?
Input
The first line of the input contains three integers n, m, r (1 ≤ n ≤ 30, 1 ≤ m ≤ 30, 1 ≤ r ≤ 1000) — the number of ways to buy the shares on the market, the number of ways to sell the shares on the market, and the number of bourles you hold now.
The next line contains n integers s_1, s_2, ..., s_n (1 ≤ s_i ≤ 1000); s_i indicates the opportunity to buy shares at the price of s_i bourles.
The following line contains m integers b_1, b_2, ..., b_m (1 ≤ b_i ≤ 1000); b_i indicates the opportunity to sell shares at the price of b_i bourles.
Output
Output a single integer — the maximum number of bourles you can hold after the evening.
Examples
Input
3 4 11
4 2 5
4 4 5 4
Output
26
Input
2 2 50
5 7
4 2
Output
50
Note
In the first example test, you have 11 bourles in the morning. It's optimal to buy 5 shares of a stock at the price of 2 bourles in the morning, and then to sell all of them at the price of 5 bourles in the evening. It's easy to verify that you'll have 26 bourles after the evening.
In the second example test, it's optimal not to take any action.
|
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
m=a[2]//(min(b))
p=m*max(c)+a[2]%min(b)
if(p>=a[2]):
print(p)
else:
print(a[2])
|
Nauuo is a girl who loves drawing circles.
One day she has drawn a circle and wanted to draw a tree on it.
The tree is a connected undirected graph consisting of n nodes and n-1 edges. The nodes are numbered from 1 to n.
Nauuo wants to draw a tree on the circle, the nodes of the tree should be in n distinct points on the circle, and the edges should be straight without crossing each other.
"Without crossing each other" means that every two edges have no common point or the only common point is an endpoint of both edges.
Nauuo wants to draw the tree using a permutation of n elements. A permutation of n elements is a sequence of integers p_1,p_2,…,p_n in which every integer from 1 to n appears exactly once.
After a permutation is chosen Nauuo draws the i-th node in the p_i-th point on the circle, then draws the edges connecting the nodes.
The tree is given, Nauuo wants to know how many permutations are there so that the tree drawn satisfies the rule (the edges are straight without crossing each other). She only wants to know the answer modulo 998244353, can you help her?
It is obvious that whether a permutation is valid or not does not depend on which n points on the circle are chosen.
Input
The first line contains a single integer n (2≤ n≤ 2⋅ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines contains two integers u and v (1≤ u,v≤ n), denoting there is an edge between u and v.
It is guaranteed that the given edges form a tree.
Output
The output contains a single integer — the number of permutations suitable to draw the given tree on a circle satisfying the rule, modulo 998244353.
Examples
Input
4
1 2
1 3
2 4
Output
16
Input
4
1 2
1 3
1 4
Output
24
Note
Example 1
All valid permutations and their spanning trees are as follows.
<image>
Here is an example of invalid permutation: the edges (1,3) and (2,4) are crossed.
<image>
Example 2
Every permutation leads to a valid tree, so the answer is 4! = 24.
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
int n;
vector<int> E[500005];
long long fac[500005], ans = 1;
void init() {
fac[0] = fac[1] = 1;
for (int i = 2; i <= 200000; ++i) {
fac[i] = fac[i - 1] * i % MOD;
}
}
void dfs(int u, int fa) {
int son = 0;
for (int &v : E[u]) {
if (v == fa) continue;
dfs(v, u);
++son;
}
if (u == 1) {
(ans *= fac[son]) %= MOD;
(ans *= n) %= MOD;
} else {
(ans *= fac[son + 1]) %= MOD;
}
}
int main() {
scanf("%d", &n);
int u, v;
for (int i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
E[u].push_back(v);
E[v].push_back(u);
}
init();
dfs(1, 0);
printf("%I64d\n", ans);
}
|
A car number in Berland consists of exactly n digits. A number is called beautiful if it has at least k equal digits. Vasya wants to change the digits in his car's number so that the number became beautiful. To replace one of n digits Vasya has to pay the sum of money, equal to the absolute difference between the old digit and the new one.
Help Vasya: find the minimum sum of money he should pay to make the number of his car beautiful. You should also find the resulting beautiful number. If there are several such numbers, then print the lexicographically minimum one.
Input
The first line contains two space-separated integers n and k (2 ≤ n ≤ 104, 2 ≤ k ≤ n) which represent how many digits the number has and how many equal digits a beautiful number should have. The second line consists of n digits. It describes the old number of Vasya's car. It is guaranteed that the number contains no spaces and only contains digits.
Output
On the first line print the minimum sum of money Vasya needs to change the number. On the second line print the car's new number. If there are several solutions, print the lexicographically minimum one.
Examples
Input
6 5
898196
Output
4
888188
Input
3 2
533
Output
0
533
Input
10 6
0001112223
Output
3
0000002223
Note
In the first sample replacing the second digit with an "8" costs |9 - 8| = 1. Replacing the fifth digit with an "8" costs the same. Replacing the sixth digit costs |6 - 8| = 2. As a result, Vasya will pay 1 + 1 + 2 = 4 for a beautiful number "888188".
The lexicographical comparison of strings is performed by the < operator in modern programming languages. The string x is lexicographically smaller than the string y, if there exists such i (1 ≤ i ≤ n), that xi < yi, and for any j (1 ≤ j < i) xj = yj. The strings compared in this problem will always have the length n.
|
s=(raw_input()).split()
n=int(s[0])
k=int(s[1])
s=raw_input()
s=[ch for ch in s]
c=10*[0]
for i in range(len(s)):
j=int(s[i])
c[j]=c[j]+1
from string import join
def choosevalue(m):
global n,k,s,c
sol=[0,'']
if (c[m]>=k):
sol[1]=s
return sol
p=s[:]
remain=k-c[m]
for i in range(1,10,1):
L=m-i
R=m+i
if (((L<0) and (R>9)) or (remain==0)):
sol[1]=p
return sol
if ((R<10)and (remain>0)):
R=str(R)
for j in range(len(p)):
if (p[j]==R):
p[j]=str(m)
sol[0]=sol[0]+i
remain=remain-1
if (remain==0):
sol[1]=p
return sol
if (L>=0):
L=str(L)
for j in range(len(p)-1,-1,-1):
if (p[j]==L):
p[j]=str(m)
sol[0]=sol[0]+i
remain=remain-1
if (remain==0):
sol[1]=p
return sol
sol[1]=p
return sol
solution=choosevalue(0)
for x in range(1,10,1):
test=choosevalue(x)
if (test[0]<solution[0]):
solution=test
else:
if (test[0]==solution[0]):
for j in range(n):
if (int(test[1][j])<int(solution[1][j])):
solution=test
break
else:
if (int(test[1][j])>int(solution[1][j])):
break
print solution[0]
print "".join(solution[1])
|
It is a holiday season, and Koala is decorating his house with cool lights! He owns n lights, all of which flash periodically.
After taking a quick glance at them, Koala realizes that each of his lights can be described with two parameters a_i and b_i. Light with parameters a_i and b_i will toggle (on to off, or off to on) every a_i seconds starting from the b_i-th second. In other words, it will toggle at the moments b_i, b_i + a_i, b_i + 2 ⋅ a_i and so on.
You know for each light whether it's initially on or off and its corresponding parameters a_i and b_i. Koala is wondering what is the maximum number of lights that will ever be on at the same time. So you need to find that out.
<image> Here is a graphic for the first example.
Input
The first line contains a single integer n (1 ≤ n ≤ 100), the number of lights.
The next line contains a string s of n characters. The i-th character is "1", if the i-th lamp is initially on. Otherwise, i-th character is "0".
The i-th of the following n lines contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ 5) — the parameters of the i-th light.
Output
Print a single integer — the maximum number of lights that will ever be on at the same time.
Examples
Input
3
101
3 3
3 2
3 1
Output
2
Input
4
1111
3 4
5 2
3 1
3 2
Output
4
Input
6
011100
5 3
5 5
2 4
3 5
4 2
1 5
Output
6
Note
For first example, the lamps' states are shown in the picture above. The largest number of simultaneously on lamps is 2 (e.g. at the moment 2).
In the second example, all lights are initially on. So the answer is 4.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, a[N], b[N], st[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%1d", &st[i]);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i], &b[i]);
int ans = 0;
for (int i = 1; i <= 100000; i++) {
int sum = 0;
for (int j = 1; j <= n; j++) {
sum += st[j];
if (i >= b[j] && (i - b[j]) % a[j] == 0) st[j] ^= 1;
}
ans = max(ans, sum);
}
printf("%d\n", ans);
return 0;
}
|
You have two integers l and r. Find an integer x which satisfies the conditions below:
* l ≤ x ≤ r.
* All digits of x are different.
If there are multiple answers, print any of them.
Input
The first line contains two integers l and r (1 ≤ l ≤ r ≤ 10^{5}).
Output
If an answer exists, print any of them. Otherwise, print -1.
Examples
Input
121 130
Output
123
Input
98766 100000
Output
-1
Note
In the first example, 123 is one of the possible answers. However, 121 can't be the answer, because there are multiple 1s on different digits.
In the second example, there is no valid answer.
|
l, r =map(int, input().split())
for i in range(l,r+1):
n = 0
a = str(i)
for j in a:
if a.count(j) == 1:
n = n+1
else:
pass
if n == len(a):
break
if n == len(a):
print(a)
else:
print('-1')
|
Two players decided to play one interesting card game.
There is a deck of n cards, with values from 1 to n. The values of cards are pairwise different (this means that no two different cards have equal values). At the beginning of the game, the deck is completely distributed between players such that each player has at least one card.
The game goes as follows: on each turn, each player chooses one of their cards (whichever they want) and puts on the table, so that the other player doesn't see which card they chose. After that, both cards are revealed, and the player, value of whose card was larger, takes both cards in his hand. Note that as all cards have different values, one of the cards will be strictly larger than the other one. Every card may be played any amount of times. The player loses if he doesn't have any cards.
For example, suppose that n = 5, the first player has cards with values 2 and 3, and the second player has cards with values 1, 4, 5. Then one possible flow of the game is:
* The first player chooses the card 3. The second player chooses the card 1. As 3>1, the first player gets both cards. Now the first player has cards 1, 2, 3, the second player has cards 4, 5.
* The first player chooses the card 3. The second player chooses the card 4. As 3<4, the second player gets both cards. Now the first player has cards 1, 2. The second player has cards 3, 4, 5.
* The first player chooses the card 1. The second player chooses the card 3. As 1<3, the second player gets both cards. Now the first player has only the card 2. The second player has cards 1, 3, 4, 5.
* The first player chooses the card 2. The second player chooses the card 4. As 2<4, the second player gets both cards. Now the first player is out of cards and loses. Therefore, the second player wins.
Who will win if both players are playing optimally? It can be shown that one of the players has a winning strategy.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). The description of the test cases follows.
The first line of each test case contains three integers n, k_1, k_2 (2 ≤ n ≤ 100, 1 ≤ k_1 ≤ n - 1, 1 ≤ k_2 ≤ n - 1, k_1 + k_2 = n) — the number of cards, number of cards owned by the first player and second player correspondingly.
The second line of each test case contains k_1 integers a_1, ..., a_{k_1} (1 ≤ a_i ≤ n) — the values of cards of the first player.
The third line of each test case contains k_2 integers b_1, ..., b_{k_2} (1 ≤ b_i ≤ n) — the values of cards of the second player.
It is guaranteed that the values of all cards are different.
Output
For each test case, output "YES" in a separate line, if the first player wins. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Example
Input
2
2 1 1
2
1
5 2 3
2 3
1 4 5
Output
YES
NO
Note
In the first test case of the example, there is only one possible move for every player: the first player will put 2, the second player will put 1. 2>1, so the first player will get both cards and will win.
In the second test case of the example, it can be shown that it is the second player who has a winning strategy. One possible flow of the game is illustrated in the statement.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
int x, y, k;
int num1 = -1, num2 = -1, num;
cin >> k >> x >> y;
for (int i = 0; i < x; i++) {
cin >> num;
num1 = max(num1, num);
}
for (int i = 0; i < y; i++) {
cin >> num;
num2 = max(num2, num);
}
if (num1 > num2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
|
[MisoilePunch♪ - 彩](https://www.youtube.com/watch?v=5VleIdkEeak)
This is an interactive problem!
On a normal day at the hidden office in A.R.C. Markland-N, Rin received an artifact, given to her by the exploration captain Sagar.
After much analysis, she now realizes that this artifact contains data about a strange flower, which has existed way before the New Age. However, the information about its chemical structure has been encrypted heavily.
The chemical structure of this flower can be represented as a string p. From the unencrypted papers included, Rin already knows the length n of that string, and she can also conclude that the string contains at most three distinct letters: "C" (as in Carbon), "H" (as in Hydrogen), and "O" (as in Oxygen).
At each moment, Rin can input a string s of an arbitrary length into the artifact's terminal, and it will return every starting position of s as a substring of p.
However, the artifact has limited energy and cannot be recharged in any way, since the technology is way too ancient and is incompatible with any current A.R.C.'s devices. To be specific:
* The artifact only contains 7/5 units of energy.
* For each time Rin inputs a string s of length t, the artifact consumes (1)/(t^2) units of energy.
* If the amount of energy reaches below zero, the task will be considered failed immediately, as the artifact will go black forever.
Since the artifact is so precious yet fragile, Rin is very nervous to attempt to crack the final data. Can you give her a helping hand?
Interaction
The interaction starts with a single integer t (1 ≤ t ≤ 500), the number of test cases. The interaction for each testcase is described below:
First, read an integer n (4 ≤ n ≤ 50), the length of the string p.
Then you can make queries of type "? s" (1 ≤ |s| ≤ n) to find the occurrences of s as a substring of p.
After the query, you need to read its result as a series of integers in a line:
* The first integer k denotes the number of occurrences of s as a substring of p (-1 ≤ k ≤ n). If k = -1, it means you have exceeded the energy limit or printed an invalid query, and you need to terminate immediately, to guarantee a "Wrong answer" verdict, otherwise you might get an arbitrary verdict because your solution will continue to read from a closed stream.
* The following k integers a_1, a_2, …, a_k (1 ≤ a_1 < a_2 < … < a_k ≤ n) denote the starting positions of the substrings that match the string s.
When you find out the string p, print "! p" to finish a test case. This query doesn't consume any energy. The interactor will return an integer 1 or 0. If the interactor returns 1, you can proceed to the next test case, or terminate the program if it was the last testcase.
If the interactor returns 0, it means that your guess is incorrect, and you should to terminate to guarantee a "Wrong answer" verdict.
Note that in every test case the string p is fixed beforehand and will not change during the queries, i.e. the interactor is not adaptive.
After printing any query do not forget to print end of line and flush the output. Otherwise, you might 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 the documentation for other languages.
Hacks
For hack, use the following format. Note that you can only hack with one test case:
The first line should contain a single integer t (t = 1).
The second line should contain an integer n (4 ≤ n ≤ 50) — the string's size.
The third line should contain a string of size n, consisting of characters "C", "H" and "O" only. This is the string contestants will have to find out.
Examples
Input
1
4
2 1 2
1 2
0
1
Output
? C
? CH
? CCHO
! CCHH
Input
2
5
0
2 2 3
1
8
1 5
1 5
1 3
2 1 2
1
Output
? O
? HHH
! CHHHH
? COO
? COOH
? HCCOO
? HH
! HHHCCOOH
Note
Note that the example interaction contains extra empty lines so that it's easier to read. The real interaction doesn't contain any empty lines and you shouldn't print any extra empty lines as well.
|
#include <bits/stdc++.h>
using namespace std;
int n, minID;
string res, key[3] = {"C", "H"};
void fill(int p, char F) {
res[p] = F;
minID = min(minID, p);
}
void query(char cmd, string trial) {
cout << cmd << " " << trial << '\n';
;
cout.flush();
if (cmd == '?') {
int T, p;
cin >> T;
for (int t = 1; t <= T; t++) {
cin >> p;
p--;
for (int i = 0; i < trial.length(); i++) {
fill(p + i, trial[i]);
}
}
} else {
int correct;
cin >> correct;
}
}
void Input() {
cin >> n;
minID = --n;
res.clear();
res.resize(n + 1, 'L');
}
void Solve() {
query('?', "CO");
query('?', "CH");
query('?', "HO");
query('?', "HC");
if (minID == n) {
query('?', "OOO");
query('?', "CCC");
query('?', "HHH");
if (minID == n) {
query('?', "OOCC");
if (minID == n) {
fill(0, 'O');
fill(1, 'O');
fill(2, 'H');
fill(3, 'H');
}
} else {
if (minID)
for (int i = minID - 1; i >= 0; i--) {
fill(i, 'O');
}
if (res[n] == 'L') {
string trial = res;
trial[n] = 'C';
if (trial[n - 1] == 'L') trial[n - 1] = 'C';
query('?', trial);
if (res[n] == 'L') {
fill(n, 'H');
if (res[n - 1] == 'L') fill(n - 1, 'H');
}
}
}
} else {
int L, R;
L = R = minID;
while (R < n && res[R + 1] != 'L') R++;
string trial;
while (L) {
trial = res.substr(L, 1) + res.substr(L, R - L + 1);
query('?', trial);
if (minID == L)
for (int i = 0; i <= L - 1; i++) fill(i, 'O');
while (L && res[L - 1] != 'L') L--;
}
while (R < n) {
query('?', res.substr(L, R - L + 1) + res[R]);
if (res[R + 1] == 'L') {
query('?', res.substr(L, R - L + 1) + 'C');
if (res[R + 1] == 'L')
fill(++R, 'H');
else
R++;
while (res[R + 1] == 'L' && R < n) fill(R + 1, res[R]), R++;
}
while (R < n && res[R + 1] != 'L') R++;
}
}
query('!', res);
}
int main() {
int T;
cin >> T;
while (T--) {
Input();
Solve();
}
return 0;
}
|
The Red Kingdom is attacked by the White King and the Black King!
The Kingdom is guarded by n castles, the i-th castle is defended by a_i soldiers. To conquer the Red Kingdom, the Kings have to eliminate all the defenders.
Each day the White King launches an attack on one of the castles. Then, at night, the forces of the Black King attack a castle (possibly the same one). Then the White King attacks a castle, then the Black King, and so on. The first attack is performed by the White King.
Each attack must target a castle with at least one alive defender in it. There are three types of attacks:
* a mixed attack decreases the number of defenders in the targeted castle by x (or sets it to 0 if there are already less than x defenders);
* an infantry attack decreases the number of defenders in the targeted castle by y (or sets it to 0 if there are already less than y defenders);
* a cavalry attack decreases the number of defenders in the targeted castle by z (or sets it to 0 if there are already less than z defenders).
The mixed attack can be launched at any valid target (at any castle with at least one soldier). However, the infantry attack cannot be launched if the previous attack on the targeted castle had the same type, no matter when and by whom it was launched. The same applies to the cavalry attack. A castle that was not attacked at all can be targeted by any type of attack.
The King who launches the last attack will be glorified as the conqueror of the Red Kingdom, so both Kings want to launch the last attack (and they are wise enough to find a strategy that allows them to do it no matter what are the actions of their opponent, if such strategy exists). The White King is leading his first attack, and you are responsible for planning it. Can you calculate the number of possible options for the first attack that allow the White King to launch the last attack? Each option for the first attack is represented by the targeted castle and the type of attack, and two options are different if the targeted castles or the types of attack are different.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
Then, the test cases follow. Each test case is represented by two lines.
The first line contains four integers n, x, y and z (1 ≤ n ≤ 3 ⋅ 10^5, 1 ≤ x, y, z ≤ 5).
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}).
It is guaranteed that the sum of values of n over all test cases in the input does not exceed 3 ⋅ 10^5.
Output
For each test case, print the answer to it: the number of possible options for the first attack of the White King (or 0, if the Black King can launch the last attack no matter how the White King acts).
Examples
Input
3
2 1 3 4
7 6
1 1 2 3
1
1 1 2 2
3
Output
2
3
0
Input
10
6 5 4 5
2 3 2 3 1 3
1 5 2 3
10
4 4 2 3
8 10 8 5
2 2 1 4
8 5
3 5 3 5
9 2 10
4 5 5 5
2 10 4 2
2 3 1 4
1 10
3 1 5 3
9 8 7
2 5 4 5
8 8
3 5 1 4
5 5 10
Output
0
2
1
2
5
12
5
0
0
2
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
inline long long int gcd(long long int a, long long int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
inline long long int lcm(long long int a, long long int b) {
return a / gcd(a, b) * b;
}
inline long long int pwm(long long int xx, long long int pow,
long long int MD) {
if (pow < 0) {
pow = pow % (MD - 1) + MD - 1;
}
long long int mlt = 1;
while (pow) {
if (pow & 1) {
mlt *= xx;
mlt %= MD;
}
xx *= xx;
pow >>= 1;
xx %= MD;
}
return mlt;
}
inline long long int gcdex(long long int a, long long int b, long long int &x,
long long int &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long int xx, yy;
long long int gc = gcdex(b, a % b, yy, xx);
x = xx;
y = yy - (a / b) * xx;
return gc;
}
inline int inv(long long int r, int _mod) {
return pwm(r % _mod, _mod - 2, _mod);
}
inline int64_t hilbertOrder(int x, int y, int pow, int rotate) {
if (pow == 0) {
return 0;
}
int hpow = 1 << (pow - 1);
int seg = (x < hpow) ? ((y < hpow) ? 0 : 3) : ((y < hpow) ? 1 : 2);
seg = (seg + rotate) & 3;
const int rotateDelta[4] = {3, 0, 0, 1};
int nx = x & (x ^ hpow), ny = y & (y ^ hpow);
int nrot = (rotate + rotateDelta[seg]) & 3;
int64_t subSquareSize = int64_t(1) << (2 * pow - 2);
int64_t ans = seg * subSquareSize;
int64_t add = hilbertOrder(nx, ny, pow - 1, nrot);
ans += (seg == 1 || seg == 2) ? add : (subSquareSize - add - 1);
return ans;
}
struct tup {
int predper, per;
};
int grandi[1000][3];
tup per[6][6][6];
vector<long long int> arr;
int x, y, z;
int mex(vector<int> kek) {
for (int i = 0; i <= 4; i++) {
bool ok = false;
for (int son : kek) {
if (son == i) ok = true;
}
if (!ok) return i;
}
}
void precalc() {
for (x = 1; x < 6; x++) {
for (y = 1; y < 6; y++) {
for (z = 1; z < 6; z++) {
for (int i = 1; i < 1000; i++) {
grandi[i][0] =
mex({grandi[max(i - x, 0)][0], grandi[max(i - y, 0)][1],
grandi[max(i - z, 0)][2]});
grandi[i][1] =
mex({grandi[max(i - x, 0)][0], grandi[max(i - z, 0)][2]});
grandi[i][2] =
mex({grandi[max(i - x, 0)][0], grandi[max(i - y, 0)][1]});
}
for (int i = 0; i < 1000; i++) {
bool kekk = false;
for (int j = i + 1; j < 1000 - 6; j++) {
bool ok = true;
for (int s = 0; s < 6; s++) {
for (int h = 0; h < 3; h++) {
if (grandi[i + s][h] != grandi[j + s][h]) ok = false;
}
}
if (ok) {
per[x][y][z] = {i, j - i};
kekk = true;
break;
}
}
if (kekk) break;
}
}
}
}
for (x = 1; x < 6; x++) {
for (y = 1; y < 6; y++) {
for (z = 1; z < 6; z++) {
}
}
}
}
int getgrandi(long long int n, int laststep) {
if (n < 40) {
return grandi[n][laststep];
}
return grandi[(n - per[x][y][z].predper) % per[x][y][z].per +
per[x][y][z].predper][laststep];
}
int zaebalsya[3];
void solve() {
int n;
cin >> n;
cin >> x >> y >> z;
zaebalsya[0] = x;
zaebalsya[1] = y;
zaebalsya[2] = z;
arr.resize(n);
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 1; i < 40; i++) {
grandi[i][0] = mex({grandi[max(i - x, 0)][0], grandi[max(i - y, 0)][1],
grandi[max(i - z, 0)][2]});
grandi[i][1] = mex({grandi[max(i - x, 0)][0], grandi[max(i - z, 0)][2]});
grandi[i][2] = mex({grandi[max(i - x, 0)][0], grandi[max(i - y, 0)][1]});
}
int ans = 0;
int allxor = 0;
for (int i = 0; i < n; i++) {
allxor ^= getgrandi(arr[i], 0);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
int res = allxor;
res ^= getgrandi(arr[i], 0);
res ^= getgrandi(max(arr[i] - zaebalsya[j], (long long int)0), j);
ans += (res == 0);
}
}
cout << ans << endl;
}
void shit() {
per[1][1][1] = {0, 2};
per[1][1][2] = {0, 3};
per[1][1][3] = {0, 4};
per[1][1][4] = {0, 5};
per[1][1][5] = {0, 6};
per[1][2][1] = {0, 3};
per[1][2][2] = {0, 3};
per[1][2][3] = {8, 4};
per[1][2][4] = {10, 5};
per[1][2][5] = {0, 6};
per[1][3][1] = {0, 4};
per[1][3][2] = {8, 4};
per[1][3][3] = {3, 2};
per[1][3][4] = {12, 7};
per[1][3][5] = {11, 2};
per[1][4][1] = {0, 5};
per[1][4][2] = {10, 5};
per[1][4][3] = {12, 7};
per[1][4][4] = {3, 5};
per[1][4][5] = {26, 3};
per[1][5][1] = {0, 6};
per[1][5][2] = {0, 6};
per[1][5][3] = {11, 2};
per[1][5][4] = {26, 3};
per[1][5][5] = {5, 2};
per[2][1][1] = {0, 3};
per[2][1][2] = {5, 3};
per[2][1][3] = {8, 4};
per[2][1][4] = {7, 5};
per[2][1][5] = {11, 6};
per[2][2][1] = {5, 3};
per[2][2][2] = {0, 4};
per[2][2][3] = {0, 5};
per[2][2][4] = {0, 6};
per[2][2][5] = {0, 7};
per[2][3][1] = {8, 4};
per[2][3][2] = {0, 5};
per[2][3][3] = {0, 5};
per[2][3][4] = {0, 6};
per[2][3][5] = {12, 7};
per[2][4][1] = {7, 5};
per[2][4][2] = {0, 6};
per[2][4][3] = {0, 6};
per[2][4][4] = {0, 6};
per[2][4][5] = {20, 7};
per[2][5][1] = {11, 6};
per[2][5][2] = {0, 7};
per[2][5][3] = {12, 7};
per[2][5][4] = {20, 7};
per[2][5][5] = {4, 7};
per[3][1][1] = {3, 2};
per[3][1][2] = {8, 4};
per[3][1][3] = {10, 4};
per[3][1][4] = {13, 5};
per[3][1][5] = {9, 6};
per[3][2][1] = {8, 4};
per[3][2][2] = {0, 5};
per[3][2][3] = {7, 5};
per[3][2][4] = {11, 6};
per[3][2][5] = {12, 7};
per[3][3][1] = {10, 4};
per[3][3][2] = {7, 5};
per[3][3][3] = {0, 6};
per[3][3][4] = {0, 7};
per[3][3][5] = {0, 8};
per[3][4][1] = {13, 5};
per[3][4][2] = {11, 6};
per[3][4][3] = {0, 7};
per[3][4][4] = {0, 7};
per[3][4][5] = {0, 8};
per[3][5][1] = {9, 6};
per[3][5][2] = {12, 7};
per[3][5][3] = {0, 8};
per[3][5][4] = {0, 8};
per[3][5][5] = {0, 8};
per[4][1][1] = {3, 5};
per[4][1][2] = {14, 3};
per[4][1][3] = {15, 5};
per[4][1][4] = {17, 5};
per[4][1][5] = {22, 6};
per[4][2][1] = {14, 3};
per[4][2][2] = {0, 6};
per[4][2][3] = {11, 6};
per[4][2][4] = {9, 6};
per[4][2][5] = {17, 7};
per[4][3][1] = {15, 5};
per[4][3][2] = {11, 6};
per[4][3][3] = {0, 7};
per[4][3][4] = {9, 7};
per[4][3][5] = {14, 8};
per[4][4][1] = {17, 5};
per[4][4][2] = {9, 6};
per[4][4][3] = {9, 7};
per[4][4][4] = {0, 8};
per[4][4][5] = {0, 9};
per[4][5][1] = {22, 6};
per[4][5][2] = {17, 7};
per[4][5][3] = {14, 8};
per[4][5][4] = {0, 9};
per[4][5][5] = {0, 9};
per[5][1][1] = {5, 2};
per[5][1][2] = {11, 3};
per[5][1][3] = {12, 2};
per[5][1][4] = {18, 6};
per[5][1][5] = {26, 6};
per[5][2][1] = {11, 3};
per[5][2][2] = {4, 7};
per[5][2][3] = {12, 7};
per[5][2][4] = {13, 7};
per[5][2][5] = {16, 7};
per[5][3][1] = {12, 2};
per[5][3][2] = {12, 7};
per[5][3][3] = {0, 8};
per[5][3][4] = {14, 8};
per[5][3][5] = {11, 8};
per[5][4][1] = {18, 6};
per[5][4][2] = {13, 7};
per[5][4][3] = {14, 8};
per[5][4][4] = {0, 9};
per[5][4][5] = {11, 9};
per[5][5][1] = {26, 6};
per[5][5][2] = {16, 7};
per[5][5][3] = {11, 8};
per[5][5][4] = {11, 9};
per[5][5][5] = {0, 10};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
unsigned int beg_time = clock();
shit();
int n;
cin >> n;
for (int i = 0; i < n; i++) solve();
unsigned int end_time = clock();
return 0;
}
|
You have n students under your control and you have to compose exactly two teams consisting of some subset of your students. Each student had his own skill, the i-th student skill is denoted by an integer a_i (different students can have the same skills).
So, about the teams. Firstly, these two teams should have the same size. Two more constraints:
* The first team should consist of students with distinct skills (i.e. all skills in the first team are unique).
* The second team should consist of students with the same skills (i.e. all skills in the second team are equal).
Note that it is permissible that some student of the first team has the same skill as a student of the second team.
Consider some examples (skills are given):
* [1, 2, 3], [4, 4] is not a good pair of teams because sizes should be the same;
* [1, 1, 2], [3, 3, 3] is not a good pair of teams because the first team should not contain students with the same skills;
* [1, 2, 3], [3, 4, 4] is not a good pair of teams because the second team should contain students with the same skills;
* [1, 2, 3], [3, 3, 3] is a good pair of teams;
* [5], [6] is a good pair of teams.
Your task is to find the maximum possible size x for which it is possible to compose a valid pair of teams, where each team size is x (skills in the first team needed to be unique, skills in the second team should be the same between them). A student cannot be part of more than one team.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the skill of the i-th student. Different students can have the same skills.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the maximum possible size x for which it is possible to compose a valid pair of teams, where each team size is x.
Example
Input
4
7
4 2 4 1 4 3 4
5
2 1 5 4 3
1
1
4
1 1 1 3
Output
3
1
0
2
Note
In the first test case of the example, it is possible to construct two teams of size 3: the first team is [1, 2, 4] and the second team is [4, 4, 4]. Note, that there are some other ways to construct two valid teams of size 3.
|
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
d = {}
maxd = 0
for x in a:
d[x] = d.get(x, 0) + 1
if d[x] > maxd:
maxd = d[x]
print(max(min(len(d)-1, maxd), min(len(d), maxd-1)))
|
You have to restore the wall. The wall consists of N pillars of bricks, the height of the i-th pillar is initially equal to h_{i}, the height is measured in number of bricks. After the restoration all the N pillars should have equal heights.
You are allowed the following operations:
* put a brick on top of one pillar, the cost of this operation is A;
* remove a brick from the top of one non-empty pillar, the cost of this operation is R;
* move a brick from the top of one non-empty pillar to the top of another pillar, the cost of this operation is M.
You cannot create additional pillars or ignore some of pre-existing pillars even if their height becomes 0.
What is the minimal total cost of restoration, in other words, what is the minimal total cost to make all the pillars of equal height?
Input
The first line of input contains four integers N, A, R, M (1 ≤ N ≤ 10^{5}, 0 ≤ A, R, M ≤ 10^{4}) — the number of pillars and the costs of operations.
The second line contains N integers h_{i} (0 ≤ h_{i} ≤ 10^{9}) — initial heights of pillars.
Output
Print one integer — the minimal cost of restoration.
Examples
Input
3 1 100 100
1 3 8
Output
12
Input
3 100 1 100
1 3 8
Output
9
Input
3 100 100 1
1 3 8
Output
4
Input
5 1 2 4
5 5 3 6 5
Output
4
Input
5 1 2 2
5 5 3 6 5
Output
3
|
#!/usr/bin/env python3
import io
import os
from bisect import bisect
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def get_str():
return input().decode().strip()
def rint():
return map(int, input().split())
def oint():
return int(input())
def find_lu_value(th):
hi = bisect(h, th) - 1
lv = th * (hi + 1) - ps[hi]
uv = (ps[n - 1] - ps[hi]) - (n - 1 - hi) * th
return lv, uv
def calc_cost(th):
cost = 0
l, u = find_lu_value(th)
if l > u:
cost += u * m + (l - u) * a
else:
cost += l * m + (u - l) * r
return cost
def calc_prefixsum(h):
ps = [h[0]]
for i in range(1, n):
ps.append(h[i] + ps[-1])
return ps
n, a, r, m = rint()
h = list(rint())
m = min(m, a + r)
h.sort()
ps = calc_prefixsum(h)
ans = 10**99
lv = h[0]
rv = h[-1]
ans = min(ans, calc_cost(lv), calc_cost(rv), calc_cost(lv+1))
while rv-lv >= 2:
mv = (rv-lv)//2 + lv
mc = calc_cost(mv)
rc = calc_cost(mv+1)
ans = min(ans, rc, mc)
if mc < rc:
rv = mv
elif mc > rc:
lv = mv
print(ans)
|
You're given an array of n integers between 0 and n inclusive.
In one operation, you can choose any element of the array and replace it by the MEX of the elements of the array (which may change after the operation).
For example, if the current array is [0, 2, 2, 1, 4], you can choose the second element and replace it by the MEX of the present elements — 3. Array will become [0, 3, 2, 1, 4].
You must make the array non-decreasing, using at most 2n operations.
It can be proven that it is always possible. Please note that you do not have to minimize the number of operations. If there are many solutions, you can print any of them.
–
An array b[1 … n] is non-decreasing if and only if b_1 ≤ b_2 ≤ … ≤ b_n.
The MEX (minimum excluded) of an array is the smallest non-negative integer that does not belong to the array. For instance:
* The MEX of [2, 2, 1] is 0, because 0 does not belong to the array.
* The MEX of [3, 1, 0, 1] is 2, because 0 and 1 belong to the array, but 2 does not.
* The MEX of [0, 3, 1, 2] is 4 because 0, 1, 2 and 3 belong to the array, but 4 does not.
It's worth mentioning that the MEX of an array of length n is always between 0 and n inclusive.
Input
The first line contains a single integer t (1 ≤ t ≤ 200) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (3 ≤ n ≤ 1000) — length of the array.
The second line of each test case contains n integers a_1, …, a_n (0 ≤ a_i ≤ n) — elements of the array. Note that they don't have to be distinct.
It is guaranteed that the sum of n over all test cases doesn't exceed 1000.
Output
For each test case, you must output two lines:
The first line must contain a single integer k (0 ≤ k ≤ 2n) — the number of operations you perform.
The second line must contain k integers x_1, …, x_k (1 ≤ x_i ≤ n), where x_i is the index chosen for the i-th operation.
If there are many solutions, you can find any of them. Please remember that it is not required to minimize k.
Example
Input
5
3
2 2 3
3
2 1 0
7
0 7 3 1 3 7 7
9
2 0 1 1 2 4 4 2 0
9
8 4 7 6 1 2 3 0 5
Output
0
2
3 1
4
2 5 5 4
11
3 8 9 7 8 5 9 6 4 1 2
10
1 8 1 9 5 2 4 6 3 7
Note
In the first test case, the array is already non-decreasing (2 ≤ 2 ≤ 3).
Explanation of the second test case (the element modified by each operation is colored in red):
* a = [2, 1, 0] ; the initial MEX is 3.
* a = [2, 1, \color{red}{3}] ; the new MEX is 0.
* a = [\color{red}{0}, 1, 3] ; the new MEX is 2.
* The final array is non-decreasing: 0 ≤ 1 ≤ 3.
Explanation of the third test case:
* a = [0, 7, 3, 1, 3, 7, 7] ; the initial MEX is 2.
* a = [0, \color{red}{2}, 3, 1, 3, 7, 7] ; the new MEX is 4.
* a = [0, 2, 3, 1, \color{red}{4}, 7, 7] ; the new MEX is 5.
* a = [0, 2, 3, 1, \color{red}{5}, 7, 7] ; the new MEX is 4.
* a = [0, 2, 3, \color{red}{4}, 5, 7, 7] ; the new MEX is 1.
* The final array is non-decreasing: 0 ≤ 2 ≤ 3 ≤ 4 ≤ 5 ≤ 7 ≤ 7.
|
#include <bits/stdc++.h>
using namespace std;
long long int smallestDivisor(long long int n) {
if (n % 2 == 0) return 2;
for (long long int i = 3; i * i <= n; i += 2) {
if (n % i == 0) return i;
}
return n;
}
long long int max(long long int a, long long int b) { return a > b ? a : b; }
long long int min(long long int a, long long int b) { return a < b ? a : b; }
long long int gcd(long long int a, long long int b) {
while (b) {
long long int t = a;
a = b;
b = t % b;
}
return a;
}
long long int lcm(long long int a, long long int b) {
return (max(a, b) / gcd(a, b)) * min(a, b);
}
int cnt[200005] = {0};
vector<int> adj[200005];
map<int, int, greater<int> > factorize(int n) {
int count = 0;
map<int, int, greater<int> > fact;
while (!(n % 2)) {
n /= 2;
count++;
}
if (count) fact[2] += count;
for (int i = 3; i <= sqrt(n); i += 2) {
count = 0;
while ((n % i) == 0) {
count++;
n /= i;
}
if (count) fact[i] += count;
}
if (n > 2) fact[n]++;
for (auto it : fact) {
cnt[it.first]++;
adj[it.first].push_back(it.second);
}
return fact;
}
long long int power(long long int x, int p) {
if (p == 0) return 1;
long long int ans = power(x, p / 2);
ans = ans * ans;
if (p % 2 == 1) ans = ans * x;
return ans;
}
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long int> countDivisors(long long int n) {
long long int cnt = 0;
std::vector<long long int> v;
for (long long int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
v.push_back(i);
if (n / i == i)
cnt++;
else {
cnt = cnt + 2;
v.push_back(n / i);
}
}
}
return v;
}
bool isPowerOfTwo(long long int x) { return (x && !(x & (x - 1))); }
map<long long int, long long int> factors(long long int n) {
vector<long long int> f;
map<long long int, long long int> m;
for (long long int x = 2; x * x <= n; x++) {
while (n % x == 0) {
f.push_back(x);
m[x]++;
n /= x;
}
}
if (n > 1) {
f.push_back(n);
m[n]++;
}
return m;
}
bool cmp(pair<long long int, long long int> v1,
pair<long long int, long long int> v2) {
if (v1.first > v2.first) {
return true;
} else if (v1.first < v2.first) {
return false;
} else {
return v1.second < v2.second;
}
}
long long int binarySearch(long long int arr[], long long int l,
long long int r, long long int x) {
if (r >= l) {
long long int mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
int rub[2000001];
bool ispali(int n) {
int no = n;
int rev = 0;
while (no > 0) {
int ld = no % 10;
no /= 10;
rev = rev * 10 + ld;
}
if (n == rev)
return true;
else
return false;
}
void np() {
for (int i = 1; i <= 2000000; i++) {
if (ispali(i))
rub[i] = rub[i - 1] + 1;
else
rub[i] = rub[i - 1];
}
}
int pi[20000001];
bool isprime[20000001];
void seive() {
for (int i = 4; i <= 20000000; i += 2) isprime[i] = 1;
for (int i = 3; i * i <= 20000000; i += 2) {
if (!isprime[i]) {
for (int j = i * i; j <= 20000000; j += i) isprime[j] = 1;
}
}
for (int i = 2; i <= 20000000; i++) {
if (!isprime[i])
pi[i] = pi[i - 1] + 1;
else
pi[i] = pi[i - 1];
}
}
int g1;
void bfs(vector<vector<int> > &g, int pos, vector<int> visited) {
queue<int> q;
q.push(pos);
while (q.size() > 0) {
if (q.front() == g1) {
cout << "yes";
return;
}
int i = q.front();
q.pop();
visited[i] = 1;
for (int j = 0; j < g[i].size(); j++) {
if (visited[g[i][j]] == 0) {
q.push(g[i][j]);
visited[g[i][j]] = 1;
}
}
}
return;
}
void pairsort(long long int a[], long long int b[], long long int n) {
pair<long long int, long long int> pairt[n];
for (long long int i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (long long int i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long int modpower(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int modsum(long long int a, long long int b, long long int m) {
return ((a % m) + (b % m)) % m;
}
long long int modmul(long long int a, long long int b, long long int m) {
return ((a % m) * (b % m)) % m;
}
long long int modInverse(long long int a, long long int m) {
return modpower(a, m - 2, m);
}
vector<long long int> factorial() {
int i;
vector<long long int> fact(200002 + 1, 0);
fact[0] = 1;
for (i = 1; i <= 200002; i++) fact[i] = (fact[i - 1] * i) % 1000000007;
return fact;
}
long long int highestPowerof2(long long int n) {
long long int p = (long long int)log2(n);
return (long long int)pow(2, p);
}
bool sorted(long long int a[], int n) {
for (int i = 1; i < n; i++) {
if (a[i] < a[i - 1]) {
return false;
}
}
return true;
}
long long int fun(long long int a[], long long int n) {
multiset<long long int> s, ps;
for (int i = 0; i <= n; i++) {
s.insert(i);
}
for (int i = 0; i < n; i++) {
if (s.find(a[i]) != s.end()) s.erase(a[i]);
ps.insert(a[i]);
}
return *(s.begin());
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t1 = 1;
cin >> t1;
while (t1--) {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
vector<int> v;
while (sorted(a, n) == false) {
int mex = fun(a, n);
if (mex < n) {
a[mex] = mex;
v.push_back(mex);
} else {
for (int i = 0; i < n; i++) {
if (a[i] != i) {
a[i] = mex;
v.push_back(i);
break;
}
}
}
}
cout << v.size() << "\n";
for (int i = 0; i < v.size(); i++) {
cout << v[i] + 1 << " ";
}
cout << "\n";
}
return 0;
}
|
A running competition is going to be held soon. The stadium where the competition will be held can be represented by several segments on the coordinate plane:
* two horizontal segments: one connecting the points (0, 0) and (x, 0), the other connecting the points (0, y) and (x, y);
* n + 1 vertical segments, numbered from 0 to n. The i-th segment connects the points (a_i, 0) and (a_i, y); 0 = a_0 < a_1 < a_2 < ... < a_{n - 1} < a_n = x.
For example, here is a picture of the stadium with x = 10, y = 5, n = 3 and a = [0, 3, 5, 10]:
<image>
A lap is a route that goes along the segments, starts and finishes at the same point, and never intersects itself (the only two points of a lap that coincide are its starting point and ending point). The length of a lap is a total distance travelled around it. For example, the red route in the picture representing the stadium is a lap of length 24.
The competition will be held in q stages. The i-th stage has length l_i, and the organizers want to choose a lap for each stage such that the length of the lap is a divisor of l_i. The organizers don't want to choose short laps for the stages, so for each stage, they want to find the maximum possible length of a suitable lap.
Help the organizers to calculate the maximum possible lengths of the laps for the stages! In other words, for every l_i, find the maximum possible integer L such that l_i mod L = 0, and there exists a lap of length exactly L.
If it is impossible to choose such a lap then print -1.
Input
The first line contains three integers n, x and y (1 ≤ n, x, y ≤ 2 ⋅ 10^5, n ≤ x).
The second line contains n + 1 integers a_0, a_1, ..., a_n (0 = a_0 < a_1 < a_2 < ... < a_{n - 1} < a_n = x).
The third line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of stages.
The fourth line contains q even integers l_1, l_2, ..., l_q (4 ≤ l_i ≤ 10^6) — the lengths of the stages.
Output
Print q numbers. The i-th number should be equal to the maximum possible length of a suitable lap for the i-th stage, or -1 if it is impossible to choose a lap for that stage.
Example
Input
3 10 5
0 3 5 10
6
24 30 14 16 18 10
Output
24 30 14 16 -1 -1
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) {
ans = (ans * a) % 1000000007;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return ans;
}
long long find(long long i, long long a[]) {
if (a[i] == i) return i;
return a[i] = find(a[i], a);
}
void uni(long long i, long long j, long long a[], long long sz[]) {
long long x = find(i, a);
long long y = find(j, a);
if (sz[x] > sz[y])
a[y] = x;
else
a[x] = y;
sz[x] += sz[y];
sz[y] = sz[x];
}
long long ans[1000006];
bitset<200005> b1, b2;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, x, y;
cin >> n >> x >> y;
n = n + 1;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
b1.reset();
b2.reset();
for (long long i = 1; i < n; i++) {
b2.set(0, 1);
b2 <<= (a[i] - a[i - 1]);
b1 |= b2;
}
memset(ans, -1, sizeof(ans));
for (long long i = 1; i <= x; i++) {
if (b1[i]) {
for (long long j = (2 * i + 2 * y); j <= 1000000; j += 2 * i + 2 * y) {
ans[j] = 2 * i + 2 * y;
}
}
}
long long q;
cin >> q;
while (q--) {
long long x1;
cin >> x1;
cout << ans[x1] << " ";
}
return 0;
}
|
Sometimes it is not easy to come to an agreement in a bargain. Right now Sasha and Vova can't come to an agreement: Sasha names a price as high as possible, then Vova wants to remove as many digits from the price as possible. In more details, Sasha names some integer price n, Vova removes a non-empty substring of (consecutive) digits from the price, the remaining digits close the gap, and the resulting integer is the price.
For example, is Sasha names 1213121, Vova can remove the substring 1312, and the result is 121.
It is allowed for result to contain leading zeros. If Vova removes all digits, the price is considered to be 0.
Sasha wants to come up with some constraints so that Vova can't just remove all digits, but he needs some arguments supporting the constraints. To start with, he wants to compute the sum of all possible resulting prices after Vova's move.
Help Sasha to compute this sum. Since the answer can be very large, print it modulo 10^9 + 7.
Input
The first and only line contains a single integer n (1 ≤ n < 10^{10^5}).
Output
In the only line print the required sum modulo 10^9 + 7.
Examples
Input
107
Output
42
Input
100500100500
Output
428101984
Note
Consider the first example.
Vova can choose to remove 1, 0, 7, 10, 07, or 107. The results are 07, 17, 10, 7, 1, 0. Their sum is 42.
|
//make sure to make new file!
import java.io.*;
import java.util.*;
public class C675{
public static long MOD = 1000000007L;
public static long[] fac;
public static long[] ifac;
public static long i2;
public static int MAX = 100005;
public static void main(String[] args)throws IOException{
BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
/*
fac = new long[MAX];
ifac = new long[MAX];
fac[0] = 1L;
for(int k = 1; k < MAX; k++){
fac[k] = (fac[k-1]*(long)k + MOD)%MOD;
}
for(int k = 0; k < MAX; k++){
ifac[k] = modInverse(fac[k],MOD);
}*/
long[] pow10 = new long[MAX];
pow10[0] = 1L;
for(int k = 1; k < MAX; k++){
pow10[k] = (pow10[k-1]*10L + MOD)%MOD;
}
long i81 = modInverse(81L,MOD);
i2 = modInverse(2L,MOD);
char[] chs = f.readLine().toCharArray();
int n = chs.length;
long[] array = new long[n];
for(int k = 0; k < n; k++){
array[k] = (long)Character.getNumericValue(chs[k]);
}
long answer = 0L;
for(int k = 0; k < n; k++){
long addfront = (array[k]*c2((long)(k+1)) + MOD)%MOD;
addfront = (addfront*pow10[n-k-1] + MOD)%MOD;
long addback = (9L*pow10[n-k-1]*(long)(n-k-1) + MOD)%MOD;
addback = (addback - pow10[n-k-1] + 1L + MOD)%MOD;
addback = (addback * array[k] + MOD)%MOD;
addback = (addback * i81 + MOD)%MOD;
answer = (answer + addfront + addback + MOD)%MOD;
//out.println(k + " " + addfront + " " + addback);
}
out.println(answer);
out.close();
}
public static long c2(long x){
if(x < 2) return 0L;
long prod = (x*(x-1L) + MOD)%MOD;
return (prod*i2 + MOD)%MOD;
}
public static long choose(int n, int r){
if(n < r) return 0L;
long prod = (fac[n] * ifac[n-r] + MOD)%MOD;
return (prod * ifac[r] + MOD)%MOD;
}
//from geeksforgeeks
public static long modInverse(long a, long m)
{
long m0 = m;
long y = 0, x = 1;
if (m == 1L)
return 0L;
while (a > 1)
{
// q is quotient
long q = a / m;
long t = m;
// m is remainder now, process same as
// Euclid's algo
m = a % m;
a = t;
t = y;
// Update y and x
y = x - q * y;
x = t;
}
// Make x positive
if (x < 0)
x += m0;
return x;
}
}
|
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int k;
cin >> k;
int ar[n * k];
for (int i = 0; i < n * k; i++) cin >> ar[i];
int step = n - ((n + 1) / 2);
long long int sum = 0;
n = n * k;
int i = n - step - 1;
while (k--) {
sum += ar[i];
i = i - step - 1;
}
cout << sum << endl;
}
return 0;
}
|
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20.
|
// art by : Seoul_graffiti
// Last modified: 2021/01/08 22:44:15
#include <bits/stdc++.h>
using namespace std;
#define ERAGE(x) x.erase(unique(all(x)), x.end())
#define rall(x) x.rbegin(), x.rend()
#define all(x) x.begin(), x.end()
#define sz(x) (int)x.size()
#define show(x) cout << #x << " : " << x << "\n"
void no()
{
printf("NO\n");
}
void yes() { printf("YES\n"); }
void files()
{
freopen("1.in", "r", stdin);
freopen("1.out", "w", stdout);
return;
}
const int N = 1e5 + 5;
const long long M = 1e9 + 7;
void sol()
{
int n, n2, n3;
cin >> n >> n2 >> n3;
vector<int> a, b, c;
long long sum = 0;
for (int i = 0; i < n; ++i)
{
int x;
cin >> x;
a.push_back(x);
sum += x;
}
for (int i = 0; i < n2; ++i)
{
int x;
cin >> x;
b.push_back(x);
sum += x;
}
for (int i = 0; i < n3; ++i)
{
int x;
cin >> x;
c.push_back(x);
sum += x;
}
sort(all(a));
sort(all(b));
sort(all(c));
long long mn = 1e17;
long long cnt = 0;
for (int i : a)
cnt += i;
mn = min(cnt, mn);
cnt = 0;
for (int i : b)
cnt += i;
mn = min(cnt, mn);
cnt = 0;
for (int i : c)
cnt += i;
mn = min(cnt, mn);
long long dif1 = abs(a[0] + b[0]);
long long dif2 = abs(a[0] + c[0]);
long long dif3 = abs(c[0] + b[0]);
long long mx = 0;
mx = max(sum - 2 * dif1, sum - 2 * mn);
mx = max(sum - 2 * dif2, mx);
mx = max(sum - 2 * dif3, mx);
cout << mx << "\n";
}
int main()
{
//files();
int tcase = 1;
//scanf("%d", &tcase);
while (tcase--)
{
sol();
}
}
|
This is an interactive problem.
Kochiya Sanae is playing with magnets. Realizing that some of those magnets are demagnetized, she is curious to find them out.
There are n magnets, which can be of the following 3 types:
* N
* S
* - — these magnets are demagnetized.
Note that you don't know the types of these magnets beforehand.
You have a machine which can measure the force between the magnets, and you can use it at most n+⌊ log_2n⌋ times.
You can put some magnets to the left part of the machine and some to the right part of the machine, and launch the machine. Obviously, you can put one magnet to at most one side (you don't have to put all magnets). You can put the same magnet in different queries.
Then the machine will tell the force these magnets produce. Formally, let n_1,s_1 be the number of N and S magnets correspondently on the left and n_2,s_2 — on the right. Then the force between them would be n_1n_2+s_1s_2-n_1s_2-n_2s_1. Please note that the force is a signed value.
However, when the absolute value of the force is strictly larger than n, the machine will crash into pieces.
You need to find all magnets of type - (all demagnetized ones), without breaking the machine.
Note that the interactor is not adaptive. The types of the magnets are fixed before the start of the interaction and do not change with queries.
It is guaranteed that there are at least 2 magnets whose type is not -, and at least 1 magnet of type -.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
Interaction
For each test case you should start by reading an integer n (3 ≤ n ≤ 2000) — the number of the magnets.
It is guaranteed that the total sum of all n over all test cases doesn't exceed 2000.
After that you can put some magnets into the machine and make a query from the statement.
You have to print each query in three lines:
* In the first line print "? l r" (without quotes) where l and r (1 ≤ l,r < n, l+r ≤ n) respectively denote the number of the magnets you put to left and right.
* In the second line print l integers a_1, ..., a_l (1 ≤ a_i ≤ n, a_i ≠ a_j if i ≠ j) — the indices of the magnets you put to left.
* In the third line print r integers b_1, ..., b_r (1 ≤ b_i ≤ n, b_i ≠ b_j if i ≠ j) — the indices of the magnets you put to right.
* The same magnet can't be put to both sides in the same query. Formally, you should guarantee that a_i ≠ b_j for any i and j. However, you may leave some magnets unused.
After printing a query do not forget to output end of line and flush the output. 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.
After this, you should read an integer F — the force these magnets produce.
Note that if your query is invalid(either the query limit exceeds, the machine crashes or the arguments are invalid), the interactor will terminate immediately. In this case terminate your program to receive verdict Wrong Answer instead of arbitrary verdicts.
If you are confident about your answer, use the following format to report it:
* "! k A", where k is the number of magnets you found, and A is an array consisting of k different integers from 1 to n denoting the indices of the magnets of type - that you found. You may print elements of A in arbitrary order.
* After that, if this is the last test case, you have to terminate your program; otherwise you should immediately continue to deal with the next test case.
Note that the interactor is not adaptive. The types of the magnets are fixed before the start of interaction and do not change with queries.
Hacks
To hack a solution, use the following format:
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases in your hack.
Then follow the descriptions of the t test cases, each printed in two lines:
* The first line contains a single integer n (3 ≤ n ≤ 2000) — the number of magnets.
* The second line contains a string S of length n consisting of only N, S and -, denoting the magnets' types.
* Each of your test case should guarantee that there are at least 2 magnets whose type is not -, and at least 1 magnet of type -. Meanwhile, the total sum of n in all test cases should not exceed 2000.
Example
Input
1
4
0
1
0
0
Output
? 1 1
3
4
? 1 2
1
2 3
? 1 1
1
4
? 1 1
1
3
! 2 3 4
Note
The empty lines in the sample are just for you to better understand the interaction process. You're not required to print them.
In the sample, the types of the magnets are NN--.
At first, you put the third magnet on the left and the fourth one on the right. Both of them have type -, thus no force is produced.
Then you put the first magnet on the left and the second and third one on the right. The third magnet has type -, while the other two magnets are of type N, so the force produced is 1.
In the following two queries, the force is 0 since there is only a magnet with property - on the right.
Then we can determine that the magnets of type - are the third and the fourth one, so we should print ! 2 3 4 and exit.
|
#include <bits/stdc++.h>
using namespace std;
//.define
// #define FILE_IN_OUT
#define RET(_x) cout << (_x) << '\n'; return;
#define all(_obj) (_obj).begin(), (_obj).end()
#define loop(_n) for (int i = 0; i < (_n); ++i)
#define sz(_obj) static_cast<int>((_obj).size())
#ifdef SHJ_LOCAL
#define debug(_x) std::cerr << (#_x) << " = " << (_x) << '\n' << std::flush;
#else
#define debug(_x) {}
#endif
#define endl "\n"
template <typename P, typename Q>
P CeilDiv(P _dividend, Q _divider) {
return static_cast<P>((_dividend - 1LL + _divider) / _divider);
}
template <typename Tp>
inline void outarr(Tp _begin, Tp _end, const char* _delim = " ") {
for (Tp current = _begin; current != _end; ++current) {
std::cout << *current << _delim;
}
std::cout << '\n';
}
//.constant
using ll = int64_t;
using pii = std::pair<int, int>;
constexpr int INF = 0x3f3f3f3f;
constexpr int MOD = static_cast<int>(1e9 + 7);
//.data
bool Ask(int l1, int r1, int l2, int r2) {
cout << "? " << r1 - l1 + 1 << ' ' << r2 - l2 + 1 << endl;
for (int i = l1; i <= r1; ++i) {
cout << i << ' ';
}
cout << endl;
for (int i = l2; i <= r2; ++i) {
cout << i << ' ';
}
cout << endl << flush;
int res;
cin >> res;
return res;
}
//.code
void SolveTask() {
int n;
cin >> n;
int j = -1;
for (int i = 2; i <= n; ++i) {
if (Ask(1, i - 1, i, i)) {
j = i;
break;
}
}
vector<int> ans;
for (int i = j + 1; i <= n; ++i) {
if (!Ask(j, j, i, i)) {
ans.push_back(i);
}
}
int l = 1;
int r = j - 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (Ask(1, mid, j, j)) {
r = mid - 1;
} else {
l = mid + 1;
}
}
for (int i = 1; i <= r; ++i) {
ans.push_back(i);
}
for (int i = r + 2; i < j; ++i) {
ans.push_back(i);
}
cout << "! " << sz(ans) << ' ';
outarr(all(ans));
cout << flush;
}
int main() {
#ifdef FILE_IN_OUT
std::ifstream cin("input.txt", std::ios::in);
std::ofstream cout("output.txt", std::ios::out);
#else
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
#endif
int test_cases = 1;
cin >> test_cases;
for (int yt = 1; yt <= test_cases; ++yt) {
SolveTask();
}
#ifdef FILE_IN_OUT
cin.close();
cout.close();
#endif
return 0;
}
|
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3].
|
import math
n=int(input())
ans=[]
prod=1
count=0
for i in range(1,n-1):
if math.gcd(n,i)==1:
ans.append(str(i))
prod=(prod*i)%n
count+=1
if n==2:
print(1)
print(1)
else:
if prod % n == 1:
print(count)
print(" ".join(ans))
else:
print(count+1)
print(" ".join(ans),n-1)
|
Farmer John has a farm that consists of n pastures connected by one-directional roads. Each road has a weight, representing the time it takes to go from the start to the end of the road. The roads could have negative weight, where the cows go so fast that they go back in time! However, Farmer John guarantees that it is impossible for the cows to get stuck in a time loop, where they can infinitely go back in time by traveling across a sequence of roads. Also, each pair of pastures is connected by at most one road in each direction.
Unfortunately, Farmer John lost the map of the farm. All he remembers is an array d, where d_i is the smallest amount of time it took the cows to reach the i-th pasture from pasture 1 using a sequence of roads. The cost of his farm is the sum of the weights of each of the roads, and Farmer John needs to know the minimal cost of a farm that is consistent with his memory.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t cases follow.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of pastures.
The second line of each test case contains n space separated integers d_1, d_2, …, d_n (0 ≤ d_i ≤ 10^9) — the array d. It is guaranteed that d_1 = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, output the minimum possible cost of a farm that is consistent with Farmer John's memory.
Example
Input
3
3
0 2 3
2
0 1000000000
1
0
Output
-3
0
0
Note
In the first test case, you can add roads
* from pasture 1 to pasture 2 with a time of 2,
* from pasture 2 to pasture 3 with a time of 1,
* from pasture 3 to pasture 1 with a time of -3,
* from pasture 3 to pasture 2 with a time of -1,
* from pasture 2 to pasture 1 with a time of -2.
The total cost is 2 + 1 + -3 + -1 + -2 = -3.
In the second test case, you can add a road from pasture 1 to pasture 2 with cost 1000000000 and a road from pasture 2 to pasture 1 with cost -1000000000. The total cost is 1000000000 + -1000000000 = 0.
In the third test case, you can't add any roads. The total cost is 0.
|
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.text.CollationElementIterator;
import java.util.*;
//changed
import javax.lang.model.type.IntersectionType;
import javax.print.attribute.standard.PrinterResolution;
import javax.swing.text.html.CSS;
public class codeforces {
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;
}
}
static int m = 1000000007;
static long[][] multiply(long a[][], long b[][]) {
long res[][] = new long[2][2];
res[0][0] = ((a[0][0] * b[0][0]) % m + (a[0][1] * b[1][0]) % m) % m;
res[0][1] = ((a[0][0] * b[0][1]) % m + (a[0][1] * b[1][1]) % m) % m;
res[1][0] = ((a[1][0] * b[0][0]) % m + (a[1][1] * b[1][0]) % m) % m;
res[1][1] = ((a[1][0] * b[0][1]) % m + (a[1][1] * b[1][1]) % m) % m;
return res;
}
static boolean isKthBitSet(int n,
int k) {
if (((n >> (k)) &
1) > 0)
return true;
return false;
}
static void move(char a[], int i) {
int j = 0;
int temp1 = i;
while (j < i) {
char temp = a[i];
a[i] = a[j];
a[j] = temp;
j++;
i--;
}
for (int k = 0; k <= temp1; k++) {
a[k] = (a[k] == '0') ? '1' : '0';
}
}
static int fact(int a) {
int f = 1;
for (int i = 2; i <= a; i++)
f *= i;
return f;
}
static long gcd(long a, long b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
public static class edge
{
int v,wt;
public edge(int v,int wt)
{
this.v=v;
this.wt=wt;
}
}
public static class trip
{
int a,b,sum;
trip(int a,int b,int sum)
{
this.a=a;
this.b=b;
this.sum=sum;
}
}
public static class pair
{
int first,second;
pair(int first,int second)
{
this.first=first;
this.second=second;
}
public boolean equals(Object o) {
if (o instanceof pair) {
pair p = (pair)o;
return p.first == first && p.second == second;
}
return false;
}
public int hashCode() {
return new Integer(first).hashCode() * 31 + new Integer(second).hashCode();
}
}
public static void main(String[] args) throws IOException {
PrintWriter out = new PrintWriter(System.out);
InputReader sc = new InputReader(System.in);
int t=sc.nextInt();
while(t-->0)
{
int n=sc.nextInt();
ArrayList<Long> al=new ArrayList<>();
for(int i=0;i<n;i++)
al.add(sc.nextLong());
Collections.sort(al);
long s=0,v=0;
for(int i=2;i<n;i++)
{
s+=al.get(i-2);
v-=(al.get(i)*(i-1));
v+=s;
}
System.out.println(v);
}
}
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(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 long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
}
class MergeSort {
// Merges two subarrays of arr[].
// First subarray is arr[l..m]
// Second subarray is arr[m+1..r]
static void merge(long arr[], int l, int m, int r) {
// Find sizes of two subarrays to be merged
int n1 = m - l + 1;
int n2 = r - m;
/* Create temp arrays */
long L[] = new long[n1];
long R[] = new long[n2];
/*Copy data to temp arrays*/
for (int i = 0; i < n1; ++i)
L[i] = arr[l + i];
for (int j = 0; j < n2; ++j)
R[j] = arr[m + 1 + j];
/* Merge the temp arrays */
// Initial indexes of first and second subarrays
int i = 0, j = 0;
// Initial index of merged subarry array
int k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
/* Copy remaining elements of L[] if any */
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
/* Copy remaining elements of R[] if any */
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
// Main function that sorts arr[l..r] using
// merge()
static void sort(long arr[], int l, int r) {
if (l < r) {
// Find the middle point
int m = (l + r) / 2;
// Sort first and second halves
sort(arr, l, m);
sort(arr, m + 1, r);
// Merge the sorted halves
merge(arr, l, m, r);
}
}
}
class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N; r += N;
while (l < r) {
if ((l & 1) == 1) sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1) sumRight = op.apply(data[--r], sumRight);
l >>= 1; r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX) return MAX;
l += N;
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0) return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX)
);
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX)
);
}
}
}
class MathLib{
public static int[] sieveEratostheness(int n) {
if (n <= 32) {
int[] primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
for (int i = 0; i < primes.length; i++) {
if (n < primes[i]) {
return Arrays.copyOf(primes, i);
}
}
return primes;
}
int u = n + 32;
double lu = Math.log(u);
int[] ret = new int[(int) (u / lu + u / lu / lu * 1.5)];
ret[0] = 2;
int pos = 1;
int[] isnp = new int[(n + 1) / 32 / 2 + 1];
int sup = (n + 1) / 32 / 2 + 1;
int[] tprimes = {3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
for (int tp : tprimes) {
ret[pos++] = tp;
int[] ptn = new int[tp];
for (int i = (tp - 3) / 2; i < tp << 5; i += tp) ptn[i >> 5] |= 1 << (i & 31);
for (int j = 0; j < sup; j += tp) {
for (int i = 0; i < tp && i + j < sup; i++) {
isnp[j + i] |= ptn[i];
}
}
}
// 3,5,7
// 2x+3=n
int[] magic = {0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13, 31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14};
int h = n / 2;
for (int i = 0; i < sup; i++) {
for (int j = ~isnp[i]; j != 0; j &= j - 1) {
int pp = i << 5 | magic[(j & -j) * 0x076be629 >>> 27];
int p = 2 * pp + 3;
if (p > n) break;
ret[pos++] = p;
if ((long) p * p > n) continue;
for (int q = (p * p - 3) / 2; q <= h; q += p) isnp[q >> 5] |= 1 << q;
}
}
return Arrays.copyOf(ret, pos);
}
static boolean[] sieveOfEratosthenes(int n) {
// Create a boolean array
// "prime[0..n]" and
// initialize all entries
// it as true. A value in
// prime[i] will finally be
// false if i is Not a
// prime, else true.
boolean prime[] = new boolean[n + 1];
for (int i = 0; i <= n; i++)
prime[i] = true;
for (int p = 2; p * p <= n; p++) {
// If prime[p] is not changed, then it is a
// prime
if (prime[p] == true) {
// Update all multiples of p
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
return prime;
}
public static int getMax(int[] inputArray){
int maxValue = inputArray[0];
for(int i=1;i < inputArray.length;i++){
if(inputArray[i] > maxValue){
maxValue = inputArray[i];
}
}
return maxValue;
}
// Method for getting the minimum value
public static int getMin(int[] inputArray){
int minValue = inputArray[0];
for(int i=1;i<inputArray.length;i++){
if(inputArray[i] < minValue){
minValue = inputArray[i];
}
}
return minValue;
}
static int countSetBits(long n)
{
int count = 0;
while (n > 0) {
count += n & 1;
n >>= 1;
}
return count;
}
static long binpow(long a, long b) {
long res = 1;
while (b > 0) {
if ((b & 1)>0)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
static ArrayList<Integer> printDivisors(int n)
{
ArrayList<Integer> al=new ArrayList<>();
for (int i=2; i<=Math.sqrt(n); i++)
{
if (n%i==0)
{
// If divisors are equal, print only one
if (n/i == i)
al.add(i);
else // Otherwise print both
{
al.add(i);
al.add(n/i);
}
}
}
return al;
}
static long fastPow(long a, long b, long mod) {
if(b == 0)
return 1L;
long val = fastPow(a, b/2, mod);
if(b % 2 == 0)
return val * val % mod;
else
return val * val % mod * a % mod;
}
static int LowerBound(int a[], int x) { // x is the target value or key
int l=-1,r=a.length;
while(l+1<r) {
int m=(l+r)>>>1;
if(a[m]>=x) r=m;
else l=m;
}
return r;
}
static int UpperBound(int a[], int x) {// x is the key or target value
int l=-1,r=a.length;
while(l+1<r) {
int m=(l+r)>>>1;
if(a[m]<=x) l=m;
else r=m;
}
return l+1;
}
private static long safe_mod(long x, long m){
x %= m;
if(x<0) x += m;
return x;
}
private static long[] inv_gcd(long a, long b){
a = safe_mod(a, b);
if(a==0) return new long[]{b,0};
long s=b, t=a;
long m0=0, m1=1;
while(t>0){
long u = s/t;
s -= t*u;
m0 -= m1*u;
long tmp = s; s = t; t = tmp;
tmp = m0; m0 = m1; m1 = tmp;
}
if(m0<0) m0 += b/s;
return new long[]{s,m0};
}
public static long gcd(long a, long b){
a = java.lang.Math.abs(a);
b = java.lang.Math.abs(b);
return inv_gcd(a, b)[0];
}
public static long lcm(long a, long b){
a = java.lang.Math.abs(a);
b = java.lang.Math.abs(b);
return a / gcd(a,b) * b;
}
public static long pow_mod(long x, long n, int m){
assert n >= 0;
assert m >= 1;
if(m == 1)return 0L;
x = safe_mod(x, m);
long ans = 1L;
while(n > 0){
if((n&1) == 1) ans = (ans * x) % m;
x = (x*x) % m;
n >>>= 1;
}
return ans;
}
static long fact[]=new long[1000001];
static long inv_fact[]=new long[1000001];
static int p=1000000007;
public static void precomp()
{
fact[0]=fact[1]=1;
for(int i=2;i<=fact.length-1;i++)
{
fact[i]=(fact[i-1]*i)%p;
}
inv_fact[(int)1e6]=modpow(fact[(int)1e6],p-2);
for(int i=fact.length-2;i>=0;i--)
{
inv_fact[i]=(inv_fact[i+1]*(i+1))%p;
}
}
public static boolean summ(int n,int a,int b)
{
while(n>0)
{
if(n%10!=a && n%10!=b)return false;
n/=10;
}
return true;
}
public static long modpow(long x,long n)
{
long res=1;
while(n>0)
{
if(n%2!=0)
{
res=(res*x)%p;n--;
}
else
{
x=(x*x)%p;n/=2;
}
}
return res;
}
public static long ncr(int n,int r)
{
if(r>n || r<0 || n<0)return 0;
return fact[n]*inv_fact[r]%p*inv_fact[n-r]%p;
}
public static long[] crt(long[] r, long[] m){
assert(r.length == m.length);
int n = r.length;
long r0=0, m0=1;
for(int i=0; i<n; i++){
assert(1 <= m[i]);
long r1 = safe_mod(r[i], m[i]), m1 = m[i];
if(m0 < m1){
long tmp = r0; r0 = r1; r1 = tmp;
tmp = m0; m0 = m1; m1 = tmp;
}
if(m0%m1 == 0){
if(r0%m1 != r1) return new long[]{0,0};
continue;
}
long[] ig = inv_gcd(m0, m1);
long g = ig[0], im = ig[1];
long u1 = m1/g;
if((r1-r0)%g != 0) return new long[]{0,0};
long x = (r1-r0) / g % u1 * im % u1;
r0 += x * m0;
m0 *= u1;
if(r0<0) r0 += m0;
//System.err.printf("%d %d\n", r0, m0);
}
return new long[]{r0, m0};
}
public static long floor_sum(long n, long m, long a, long b){
long ans = 0;
if(a >= m){
ans += (n-1) * n * (a/m) / 2;
a %= m;
}
if(b >= m){
ans += n * (b/m);
b %= m;
}
long y_max = (a*n+b) / m;
long x_max = y_max * m - b;
if(y_max == 0) return ans;
ans += (n - (x_max+a-1)/a) * y_max;
ans += floor_sum(y_max, a, m, (a-x_max%a)%a);
return ans;
}
public static java.util.ArrayList<Long> divisors(long n){
java.util.ArrayList<Long> divisors = new ArrayList<>();
java.util.ArrayList<Long> large = new ArrayList<>();
for(long i=1; i*i<=n; i++) if(n%i==0){
divisors.add(i);
if(i*i<n) large.add(n/i);
}
for(int p=large.size()-1; p>=0; p--){
divisors.add(large.get(p));
}
return divisors;
}
}
|
You are given an integer a that consists of n digits. You are also given a sequence of digits s of length m. The digit in position j (1 ≤ j ≤ m) of sequence s means that you can choose an arbitrary position i (1 ≤ i ≤ n) in a and replace the digit in the chosen position i with sj. Each element in the sequence s can participate in no more than one replacing operation.
Your task is to perform such sequence of replacements, that the given number a gets maximum value. You are allowed to use not all elements from s.
Input
The first line contains positive integer a. Its length n is positive and doesn't exceed 105. The second line contains sequence of digits s. Its length m is positive and doesn't exceed 105. The digits in the sequence s are written consecutively without any separators.
The given number a doesn't contain leading zeroes.
Output
Print the maximum value that can be obtained from a after a series of replacements. You are allowed to use not all elements from s. The printed number shouldn't contain any leading zeroes.
Examples
Input
1024
010
Output
1124
Input
987
1234567
Output
987
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a;
int l = a.length(), i, j;
vector<string> s;
cin >> b;
int p = b.length();
s.push_back(b);
vector<int> visit(p, 0);
sort(s[0].rbegin(), s[0].rend());
j = 0;
for (i = 0; i < l; i++) {
if (((a[i] - 48) < (s[0][j] - 48)) && visit[j] == 0) {
a[i] = s[0][j];
j++;
}
}
cout << a;
return 0;
}
|
Zart PMP is qualified for ICPC World Finals in Harbin, China. After team excursion to Sun Island Park for snow sculpture art exposition, PMP should get back to buses before they leave. But the park is really big and he does not know how to find them.
The park has n intersections numbered 1 through n. There are m bidirectional roads that connect some pairs of these intersections. At k intersections, ICPC volunteers are helping the teams and showing them the way to their destinations. Locations of volunteers are fixed and distinct.
When PMP asks a volunteer the way to bus station, he/she can tell him the whole path. But the park is fully covered with ice and snow and everywhere looks almost the same. So PMP can only memorize at most q intersections after each question (excluding the intersection they are currently standing). He always tells volunteers about his weak memory and if there is no direct path of length (in number of roads) at most q that leads to bus station, the volunteer will guide PMP to another volunteer (who is at most q intersections away, of course). ICPC volunteers know the area very well and always tell PMP the best way. So if there exists a way to bus stations, PMP will definitely find it.
PMP's initial location is intersection s and the buses are at intersection t. There will always be a volunteer at intersection s. Your job is to find out the minimum q which guarantees that PMP can find the buses.
Input
The first line contains three space-separated integers n, m, k (2 ≤ n ≤ 105, 0 ≤ m ≤ 2·105, 1 ≤ k ≤ n) — the number of intersections, roads and volunteers, respectively. Next line contains k distinct space-separated integers between 1 and n inclusive — the numbers of cities where volunteers are located.
Next m lines describe the roads. The i-th of these lines contains two space-separated integers ui, vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — two intersections that i-th road connects. There will be at most one road between any two intersections.
Last line of input contains two space-separated integers s, t (1 ≤ s, t ≤ n, s ≠ t) — the initial location of PMP and the location of the buses. It might not always be possible to reach t from s.
It is guaranteed that there is always a volunteer at intersection s.
Output
Print on the only line the answer to the problem — the minimum value of q which guarantees that PMP can find the buses. If PMP cannot reach the buses at all, output -1 instead.
Examples
Input
6 6 3
1 3 6
1 2
2 3
4 2
5 6
4 5
3 4
1 6
Output
3
Input
6 5 3
1 5 6
1 2
2 3
3 4
4 5
6 3
1 5
Output
3
Note
The first sample is illustrated below. Blue intersections are where volunteers are located. If PMP goes in the path of dashed line, it can reach the buses with q = 3:
<image>
In the second sample, PMP uses intersection 6 as an intermediate intersection, thus the answer is 3.
|
#include <bits/stdc++.h>
using namespace std;
long long mod_v(long long num) {
if (num >= 0)
return (num % 1000000007);
else
return (num % 1000000007 + 1000000007) % 1000000007;
}
long long bigmod(long long b, long long p, long long m) {
long long res = 1 % m, x = b % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
class node {
public:
int s, w;
node(){};
node(int s, int w) {
this->s = s;
this->w = w;
};
};
bool operator<(node a, node b) {
if (a.w < b.w)
return true;
else
return false;
}
bool vol[100005] = {0};
int vis[100005] = {0};
vector<int> adj[100005];
int n;
bool solve(int q, int s, int d) {
memset(vis, 0, sizeof(vis));
vis[s] = q;
priority_queue<node> pq;
pq.push(node(s, q));
while (!pq.empty()) {
s = pq.top().s;
pq.pop();
if (s == d) return true;
for (int i = 0, ns; i < adj[s].size(); i++) {
ns = adj[s][i];
if (ns == d) return true;
if (vol[ns] == 1 && vis[ns] < q) {
vis[ns] = q;
pq.push(node(ns, vis[ns]));
} else if (vis[ns] < vis[s] - 1) {
vis[ns] = vis[s] - 1;
pq.push(node(ns, vis[ns]));
}
}
}
return false;
}
int main() {
int m, k, u, v, s, d;
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &u);
vol[u] = 1;
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
scanf("%d %d", &s, &d);
int l = 1, r = n, mid;
while (l < r) {
mid = (l + r) / 2;
if (solve(mid, s, d))
r = mid;
else
l = mid + 1;
}
if (l == n)
printf("-1\n");
else
cout << l << endl;
}
|
Сity N. has a huge problem with roads, food and IT-infrastructure. In total the city has n junctions, some pairs of them are connected by bidirectional roads. The road network consists of n - 1 roads, you can get from any junction to any other one by these roads. Yes, you're right — the road network forms an undirected tree.
Recently, the Mayor came up with a way that eliminates the problems with the food and the IT-infrastructure at the same time! He decided to put at the city junctions restaurants of two well-known cafe networks for IT professionals: "iMac D0naldz" and "Burger Bing". Since the network owners are not friends, it is strictly prohibited to place two restaurants of different networks on neighboring junctions. There are other requirements. Here's the full list:
* each junction must have at most one restaurant;
* each restaurant belongs either to "iMac D0naldz", or to "Burger Bing";
* each network should build at least one restaurant;
* there is no pair of junctions that are connected by a road and contains restaurants of different networks.
The Mayor is going to take a large tax from each restaurant, so he is interested in making the total number of the restaurants as large as possible.
Help the Mayor to analyze the situation. Find all such pairs of (a, b) that a restaurants can belong to "iMac D0naldz", b restaurants can belong to "Burger Bing", and the sum of a + b is as large as possible.
Input
The first input line contains integer n (3 ≤ n ≤ 5000) — the number of junctions in the city. Next n - 1 lines list all roads one per line. Each road is given as a pair of integers xi, yi (1 ≤ xi, yi ≤ n) — the indexes of connected junctions. Consider the junctions indexed from 1 to n.
It is guaranteed that the given road network is represented by an undirected tree with n vertexes.
Output
Print on the first line integer z — the number of sought pairs. Then print all sought pairs (a, b) in the order of increasing of the first component a.
Examples
Input
5
1 2
2 3
3 4
4 5
Output
3
1 3
2 2
3 1
Input
10
1 2
2 3
3 4
5 6
6 7
7 4
8 9
9 10
10 4
Output
6
1 8
2 7
3 6
6 3
7 2
8 1
Note
The figure below shows the answers to the first test case. The junctions with "iMac D0naldz" restaurants are marked red and "Burger Bing" restaurants are marked blue.
<image>
|
#include <bits/stdc++.h>
using namespace std;
struct fastIO {
inline fastIO operator>>(int& num) {
num = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
bool foo = 0;
if (c == '-') {
foo = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
if (foo) num = -num;
return *this;
}
inline fastIO operator>>(long long& num) {
num = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
bool foo = 0;
if (c == '-') {
foo = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
if (foo) num = -num;
return *this;
}
inline fastIO operator>>(float& num) {
scanf("%f", &num);
return *this;
}
inline fastIO operator>>(double& num) {
scanf("%lf", &num);
return *this;
}
inline fastIO operator>>(long double& num) {
scanf("%Lf", &num);
return *this;
}
inline fastIO operator>>(char& num) {
num = getchar();
while (num == ' ' || num == '\n') num = getchar();
return *this;
}
inline fastIO operator>>(char* num) {
int cnt = 0;
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
while (c != ' ' && c != '\n') {
num[cnt++] = c;
c = getchar();
}
num[cnt] = 0;
return *this;
}
inline fastIO operator>>(string& num) {
cin >> num;
return *this;
}
inline void printInt(const int& num) {
if (num < 10) {
putchar(num + '0');
return;
}
printInt(num / 10);
putchar((num % 10) + '0');
}
inline void printINT(const long long& num) {
if (num < 10) {
putchar(num + '0');
return;
}
printINT(num / 10);
putchar((num % 10) + '0');
}
inline fastIO operator<<(const int& num) {
if (num < 0)
putchar('-'), printInt(-num);
else
printInt(num);
return *this;
}
inline fastIO operator<<(const long long& num) {
if (num < 0)
putchar('-'), printINT(-num);
else
printINT(num);
return *this;
}
inline fastIO operator<<(const float& num) {
printf("%.10f", num);
return *this;
}
inline fastIO operator<<(const double& num) {
printf("%.16lf", num);
return *this;
}
inline fastIO operator<<(const long double& num) {
printf("%.20Lf", num);
return *this;
}
inline fastIO operator<<(const char& num) {
putchar(num);
return *this;
}
inline fastIO operator<<(const char* num) {
for (int i = 0; num[i]; i++) putchar(num[i]);
return *this;
}
inline fastIO operator<<(const string& num) {
cout << num;
return *this;
}
} fio;
int dp[5005];
int n;
vector<int> nei[5005];
bool can[5005];
bitset<5005> Now, tmp;
int dfs(int now, int lst) {
dp[now] = 1;
for (int i = 0; i < ((int)(nei[now]).size()); i++) {
if (nei[now][i] != lst) {
dp[now] += dfs(nei[now][i], now);
}
}
tmp.reset();
tmp.set(0);
if (n - dp[now]) {
tmp.set(n - dp[now]);
}
for (int i = 0; i < ((int)(nei[now]).size()); i++) {
if (nei[now][i] != lst) {
tmp |= tmp << dp[nei[now][i]];
}
}
Now |= tmp;
return dp[now];
}
int main() {
fio >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
fio >> a >> b;
nei[a].push_back(b);
nei[b].push_back(a);
}
dfs(1, -1);
int cnt = 0;
for (int i = 1; i < n - 1; i++) {
if (Now.test(i)) {
cnt++;
}
}
fio << cnt << '\n';
for (int i = 1; i < n - 1; i++) {
if (Now.test(i)) {
fio << i << ' ' << n - i - 1 << '\n';
}
}
return 0;
}
|
Some days ago, WJMZBMR learned how to answer the query "how many times does a string x occur in a string s" quickly by preprocessing the string s. But now he wants to make it harder.
So he wants to ask "how many consecutive substrings of s are cyclical isomorphic to a given string x". You are given string s and n strings xi, for each string xi find, how many consecutive substrings of s are cyclical isomorphic to xi.
Two strings are called cyclical isomorphic if one can rotate one string to get the other one. 'Rotate' here means 'to take some consecutive chars (maybe none) from the beginning of a string and put them back at the end of the string in the same order'. For example, string "abcde" can be rotated to string "deabc". We can take characters "abc" from the beginning and put them at the end of "de".
Input
The first line contains a non-empty string s. The length of string s is not greater than 106 characters.
The second line contains an integer n (1 ≤ n ≤ 105) — the number of queries. Then n lines follow: the i-th line contains the string xi — the string for the i-th query. The total length of xi is less than or equal to 106 characters.
In this problem, strings only consist of lowercase English letters.
Output
For each query xi print a single integer that shows how many consecutive substrings of s are cyclical isomorphic to xi. Print the answers to the queries in the order they are given in the input.
Examples
Input
baabaabaaa
5
a
ba
baa
aabaa
aaba
Output
7
5
7
3
5
Input
aabbaa
3
aa
aabb
abba
Output
2
3
3
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 10, mod = (int)1e9 + 7;
int q, last, sz;
char s[N];
struct state {
int len, link, next[26], cnt;
};
vector<state> st;
vector<bool> vis;
vector<int> adj[2 * N];
void sa_init() {
st.resize(2 * N);
vis.resize(2 * N);
st[0].link = -1;
st[0].len = 0;
last = 0;
sz = 1;
}
void sa_extend(char ch) {
int c = ch - 'a';
int cur = sz++;
st[cur].len = st[last].len + 1;
int p = last;
while (p != -1 && !st[p].next[c]) {
st[p].next[c] = cur;
p = st[p].link;
}
if (p == -1)
st[cur].link = 0;
else {
int q = st[p].next[c];
if (st[q].len == st[p].len + 1)
st[cur].link = q;
else {
int clone = sz++;
st[clone] = st[q];
st[clone].cnt = 0;
st[clone].len = st[p].len + 1;
while (p != -1 && st[p].next[c] == q) {
st[p].next[c] = clone;
p = st[p].link;
}
st[q].link = st[cur].link = clone;
}
}
last = cur;
st[cur].cnt = 1;
}
void dfs(int u) {
for (int v : adj[u]) {
dfs(v);
st[u].cnt += st[v].cnt;
}
}
int main() {
sa_init();
char x;
while ((x = getchar()) != '\n') sa_extend(x);
for (int i = 1; i < sz; i++) adj[st[i].link].push_back(i);
dfs(0);
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%s", &s);
vector<int> v;
int n = strlen(s);
int l = 0, len = 0, u = 0, ans = 0;
for (int j = 0; j < n; j++) {
while (len < n) {
int c = s[l] - 'a';
if (!st[u].next[c]) break;
u = st[u].next[c];
l++, len++;
if (l == n) l = 0;
}
if (len == n) {
if (!vis[u]) ans += st[u].cnt;
vis[u] = 1;
v.push_back(u);
}
if (u) {
if (st[st[u].link].len == len - 1) {
u = st[u].link;
}
len--;
} else
l = (l + 1) % n;
}
for (int a : v) vis[a] = 0;
printf("%d\n", ans);
}
return 0;
}
|
Maxim loves to fill in a matrix in a special manner. Here is a pseudocode of filling in a matrix of size (m + 1) × (m + 1):
<image>
Maxim asks you to count, how many numbers m (1 ≤ m ≤ n) are there, such that the sum of values in the cells in the row number m + 1 of the resulting matrix equals t.
Expression (x xor y) means applying the operation of bitwise excluding "OR" to numbers x and y. The given operation exists in all modern programming languages. For example, in languages C++ and Java it is represented by character "^", in Pascal — by "xor".
Input
A single line contains two integers n and t (1 ≤ n, t ≤ 1012, t ≤ n + 1).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
In a single line print a single integer — the answer to the problem.
Examples
Input
1 1
Output
1
Input
3 2
Output
1
Input
3 3
Output
0
Input
1000000000000 1048576
Output
118606527258
|
#include <bits/stdc++.h>
using namespace std;
long long dp[65][65][2];
int b[65];
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
long long n, t, cnt;
cin >> n >> t;
if (__builtin_popcountll(t) > 1) {
cout << 0;
return 0;
}
cnt = __builtin_ctzll(t) + 1;
cerr << cnt << endl;
n++;
for (int i = 0; i < 64; i++) b[i] = (n >> (63 - i)) & 1;
dp[0][0][0] = 1;
for (int i = 0; i < 64; i++)
for (int c = 0; c < 64; c++) {
if (b[i]) {
dp[i + 1][c][1] += dp[i][c][0];
dp[i + 1][c + 1][0] += dp[i][c][0];
} else
dp[i + 1][c][0] += dp[i][c][0];
dp[i + 1][c + 1][1] += dp[i][c][1];
dp[i + 1][c][1] += dp[i][c][1];
}
cout << dp[64][cnt][0] + dp[64][cnt][1] - (cnt == 1) << endl;
}
|
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2).
|
def abs(x):
if x<0:
return 0-x
return x
n = input()
a = map(int,raw_input().split())
a.sort()
sum=0
for i in range(1,n+1):
sum+=abs(a[i-1]-i)
print sum
|
One warm and sunny day king Copa decided to visit the shooting gallery, located at the Central Park, and try to win the main prize — big pink plush panda. The king is not good at shooting, so he invited you to help him.
The shooting gallery is an infinite vertical plane with Cartesian coordinate system on it. The targets are points on this plane. Each target is described by it's coordinates xi, and yi, by the time of it's appearance ti and by the number pi, which gives the probability that Copa hits this target if he aims at it.
A target appears and disappears instantly, so Copa can hit the target only if at the moment ti his gun sight aimed at (xi, yi). Speed of movement of the gun sight on the plane is equal to 1. Copa knows all the information about the targets beforehand (remember, he is a king!). He wants to play in the optimal way, which maximizes the expected value of the amount of hit targets. He can aim at any target at the moment 0.
Input
The first line contains integer n (1 ≤ n ≤ 1000) — amount of targets in the shooting gallery. Then n lines follow, each describing one target. Each description consists of four numbers xi, yi, ti, pi (where xi, yi, ti — integers, - 1000 ≤ xi, yi ≤ 1000, 0 ≤ ti ≤ 109, real number pi is given with no more than 6 digits after the decimal point, 0 ≤ pi ≤ 1). No two targets may be at the same point.
Output
Output the maximum expected value of the amount of targets that was shot by the king. Your answer will be accepted if it differs from the correct answer by not more than 10 - 6.
Examples
Input
1
0 0 0 0.5
Output
0.5000000000
Input
2
0 0 0 0.6
5 0 5 0.7
Output
1.3000000000
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 20;
const long double inf = 1e18;
long double dp[maxn][2];
pair<pair<long long, long long>, pair<long long, long double> > a[maxn];
bool cmp(pair<pair<long long, long long>, pair<long long, long double> > a,
pair<pair<long long, long long>, pair<long long, long double> > b) {
return a.second.first > b.second.first;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i].first.first >> a[i].first.second >> a[i].second.first >>
a[i].second.second;
sort(a, a + n, cmp);
cout << fixed << setprecision(6);
dp[0][0] = 0;
dp[0][1] = a[0].second.second;
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]);
dp[i][1] = a[i].second.second;
for (int j = i - 1; j > -1; j--)
if ((a[j].first.first - a[i].first.first) *
(a[j].first.first - a[i].first.first) +
(a[j].first.second - a[i].first.second) *
(a[j].first.second - a[i].first.second) <=
(a[j].second.first - a[i].second.first) *
(a[j].second.first - a[i].second.first))
dp[i][1] = max(dp[i][1], dp[j][1] + a[i].second.second);
}
cout << max(dp[n - 1][0], dp[n - 1][1]);
}
|
Gerald has been selling state secrets at leisure. All the secrets cost the same: n marks. The state which secrets Gerald is selling, has no paper money, only coins. But there are coins of all positive integer denominations that are powers of three: 1 mark, 3 marks, 9 marks, 27 marks and so on. There are no coins of other denominations. Of course, Gerald likes it when he gets money without the change. And all buyers respect him and try to give the desired sum without change, if possible. But this does not always happen.
One day an unlucky buyer came. He did not have the desired sum without change. Then he took out all his coins and tried to give Gerald a larger than necessary sum with as few coins as possible. What is the maximum number of coins he could get?
The formal explanation of the previous paragraph: we consider all the possible combinations of coins for which the buyer can not give Gerald the sum of n marks without change. For each such combination calculate the minimum number of coins that can bring the buyer at least n marks. Among all combinations choose the maximum of the minimum number of coins. This is the number we want.
Input
The single line contains a single integer n (1 ≤ n ≤ 1017).
Please, do not use the %lld specifier to read or write 64 bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
In a single line print an integer: the maximum number of coins the unlucky buyer could have paid with.
Examples
Input
1
Output
1
Input
4
Output
2
Note
In the first test case, if a buyer has exactly one coin of at least 3 marks, then, to give Gerald one mark, he will have to give this coin. In this sample, the customer can not have a coin of one mark, as in this case, he will be able to give the money to Gerald without any change.
In the second test case, if the buyer had exactly three coins of 3 marks, then, to give Gerald 4 marks, he will have to give two of these coins. The buyer cannot give three coins as he wants to minimize the number of coins that he gives.
|
#include <bits/stdc++.h>
using namespace std;
void io_in_data() {
freopen("data.in", "r", stdin);
freopen("data1.out", "w", stdout);
}
template <class T>
void show(T *a, int n) {
for (int i = 0; i < n; i++) cout << a[i] << " ";
puts("");
}
int inLR(int a, int L, int R) { return a >= L && a <= R; }
int movR[] = {1, -1, 0, 0};
int movC[] = {0, 0, 1, -1};
const int MAXN = 200007;
int main() {
long long n;
while (cin >> n) {
long long s = 1;
while (n % s == 0) s *= 3;
cout << (n + s - 1) / s << endl;
}
return 0;
}
|
Hooray! Berl II, the king of Berland is making a knight tournament. The king has already sent the message to all knights in the kingdom and they in turn agreed to participate in this grand event.
As for you, you're just a simple peasant. There's no surprise that you slept in this morning and were late for the tournament (it was a weekend, after all). Now you are really curious about the results of the tournament. This time the tournament in Berland went as follows:
* There are n knights participating in the tournament. Each knight was assigned his unique number — an integer from 1 to n.
* The tournament consisted of m fights, in the i-th fight the knights that were still in the game with numbers at least li and at most ri have fought for the right to continue taking part in the tournament.
* After the i-th fight among all participants of the fight only one knight won — the knight number xi, he continued participating in the tournament. Other knights left the tournament.
* The winner of the last (the m-th) fight (the knight number xm) became the winner of the tournament.
You fished out all the information about the fights from your friends. Now for each knight you want to know the name of the knight he was conquered by. We think that the knight number b was conquered by the knight number a, if there was a fight with both of these knights present and the winner was the knight number a.
Write the code that calculates for each knight, the name of the knight that beat him.
Input
The first line contains two integers n, m (2 ≤ n ≤ 3·105; 1 ≤ m ≤ 3·105) — the number of knights and the number of fights. Each of the following m lines contains three integers li, ri, xi (1 ≤ li < ri ≤ n; li ≤ xi ≤ ri) — the description of the i-th fight.
It is guaranteed that the input is correct and matches the problem statement. It is guaranteed that at least two knights took part in each battle.
Output
Print n integers. If the i-th knight lost, then the i-th number should equal the number of the knight that beat the knight number i. If the i-th knight is the winner, then the i-th number must equal 0.
Examples
Input
4 3
1 2 1
1 3 3
1 4 4
Output
3 1 4 0
Input
8 4
3 5 4
3 7 6
2 8 8
1 8 1
Output
0 8 4 6 4 8 6 1
Note
Consider the first test case. Knights 1 and 2 fought the first fight and knight 1 won. Knights 1 and 3 fought the second fight and knight 3 won. The last fight was between knights 3 and 4, knight 4 won.
|
#include <bits/stdc++.h>
using namespace std;
int a[300005];
int main() {
int n, m, i, l, r, x;
set<int> s;
cin >> n >> m;
for (i = 1; i <= n; i++) s.insert(i);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &l, &r, &x);
for (set<int>::iterator it = s.lower_bound(l);
it != s.end() && (*it) <= r;) {
if (*it != x) {
a[*it] = x;
s.erase(it++);
} else
it++;
}
}
for (i = 1; i <= n; i++) printf("%d ", a[i]);
cout << endl;
return 0;
}
|
Jack and Jill are tired of the New Year tree, now they've got a New Year cactus at home! A cactus is a connected undirected graph where any two simple cycles have at most one common vertex. In other words, this graph doesn't have any edges that lie on more than one simple cycle.
On the 31st of December they are going to decorate the cactus by hanging toys to its vertices. At most one toy is going to hang on each vertex — it's either the toy Jack hung or the toy Jill hung. It's possible for a vertex to have no toys.
Jack and Jill has been arguing, so they don't want any edge to connect two vertices where one vertex has Jack's toy and the other vertex has Jill's toy.
Jack has decided to hang a toys. What maximum number of toys b can Jill hang if they both cooperate to maximize this value? Your task is to write a program that finds the sought b for all a from 0 to the number of vertices on the New Year Cactus.
Input
The first line contains two integers n and m (1 ≤ n ≤ 2500, n - 1 ≤ m) — the number of vertices and the number of edges, correspondingly. The next m lines contain two integers a, b each (1 ≤ a, b ≤ n, a ≠ b) that mean that there is an edge connecting vertices a и b. Any pair of vertices has at most one edge between them.
Output
The first line must contain space-separated ba (for all 0 ≤ a ≤ n) where ba equals the maximum number of Jill's toys on the cactus considering that it has a Jack's toys. Numbers ba go in the order of increasing a.
Examples
Input
1 0
Output
1 0
Input
16 20
1 2
3 4
5 6
6 7
7 8
9 10
10 11
11 12
13 14
15 16
1 5
9 13
14 10
10 6
6 2
15 11
11 7
7 3
16 12
8 4
Output
16 13 12 12 10 8 8 7 6 4 4 3 3 1 0 0 0
Note
The cactus from the second example is:
<image>
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0xdddddddd, maxn = 2510;
int dp[maxn][maxn][3], pd[maxn][3], pd1[maxn][3][3], pd2[maxn][3][3], sz[maxn],
p[maxn], dfn[maxn], low[maxn], cnt, n, m, u, v;
vector<int> cyc, e[maxn];
void upd(int &a, int b) {
if (a <= b) a = b;
}
void cycle(int u, int v) {
cyc.clear();
while (1) {
cyc.push_back(v);
if (v == u) break;
v = p[v];
}
reverse(cyc.begin(), cyc.end());
for (int i = 0; i <= sz[u]; i++) {
for (int p1 = 0; p1 < 3; p1++)
for (int p2 = 0; p2 < 3; p2++) pd1[i][p1][p2] = inf;
for (int p1 = 0; p1 < 3; p1++) pd1[i][p1][p1] = dp[u][i][p1];
}
for (int l = 1; l < cyc.size(); l++) {
v = cyc[l];
for (int i = 0; i < sz[u] + 1; i++)
for (int p1 = 0; p1 < 3; p1++)
for (int p2 = 0; p2 < 3; p2++) pd2[i][p1][p2] = pd1[i][p1][p2];
for (int i = 0; i < sz[u] + sz[v] + 1; i++)
for (int p1 = 0; p1 < 3; p1++)
for (int p2 = 0; p2 < 3; p2++) pd1[i][p1][p2] = inf;
for (int i = 0; i < sz[u] + 1; i++)
for (int j = 0; j < sz[v] + 1; j++)
for (int p1 = 0; p1 < 3; p1++) {
upd(pd1[i + j][p1][0],
dp[v][j][0] +
max(pd2[i][p1][0], max(pd2[i][p1][1], pd2[i][p1][2])));
upd(pd1[i + j][p1][1],
dp[v][j][1] + max(pd2[i][p1][0], pd2[i][p1][1]));
upd(pd1[i + j][p1][2],
dp[v][j][2] + max(pd2[i][p1][0], pd2[i][p1][2]));
}
sz[u] += sz[v];
}
for (int i = 0; i < sz[u] + 1; i++) {
upd(dp[u][i][0], max(pd1[i][0][0], max(pd1[i][0][1], pd1[i][0][2])));
upd(dp[u][i][1], max(pd1[i][1][0], pd1[i][1][1]));
upd(dp[u][i][2], max(pd1[i][2][0], pd1[i][2][2]));
}
}
void dfs(int u, int f) {
p[u] = f;
dfn[u] = low[u] = ++cnt;
sz[u] = 1;
dp[u][0][0] = 0;
dp[u][1][1] = 0;
dp[u][0][2] = 1;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (v == f) continue;
if (!dfn[v]) {
dfs(v, u);
if (low[v] > dfn[u]) {
for (int p1 = 0; p1 < sz[u] + sz[v] + 1; p1++)
for (int p2 = 0; p2 < 3; p2++) pd[p1][p2] = inf;
for (int p1 = 0; p1 < sz[u] + 1; p1++)
for (int p2 = 0; p2 < sz[v] + 1; p2++) {
upd(pd[p1 + p2][0],
dp[u][p1][0] +
max(dp[v][p2][0], max(dp[v][p2][1], dp[v][p2][2])));
upd(pd[p1 + p2][1], dp[u][p1][1] + max(dp[v][p2][0], dp[v][p2][1]));
upd(pd[p1 + p2][2], dp[u][p1][2] + max(dp[v][p2][0], dp[v][p2][2]));
}
sz[u] += sz[v];
for (int p1 = 0; p1 < sz[u] + 1; p1++)
for (int p2 = 0; p2 < 3; p2++) dp[u][p1][p2] = pd[p1][p2];
}
}
low[u] = min(low[u], low[v]);
}
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (p[v] != u && dfn[v] > dfn[u]) cycle(u, v);
}
}
int main() {
scanf("%d%d", &n, &m);
memset(dp, 0xdd, sizeof(dp));
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1, 0);
for (int i = 0; i <= n; i++)
printf("%d ", max(dp[1][i][0], max(dp[1][i][1], dp[1][i][2])));
return 0;
}
|
Certainly, everyone is familiar with tic-tac-toe game. The rules are very simple indeed. Two players take turns marking the cells in a 3 × 3 grid (one player always draws crosses, the other — noughts). The player who succeeds first in placing three of his marks in a horizontal, vertical or diagonal line wins, and the game is finished. The player who draws crosses goes first. If the grid is filled, but neither Xs, nor 0s form the required line, a draw is announced.
You are given a 3 × 3 grid, each grid cell is empty, or occupied by a cross or a nought. You have to find the player (first or second), whose turn is next, or print one of the verdicts below:
* illegal — if the given board layout can't appear during a valid game;
* the first player won — if in the given board layout the first player has just won;
* the second player won — if in the given board layout the second player has just won;
* draw — if the given board layout has just let to a draw.
Input
The input consists of three lines, each of the lines contains characters ".", "X" or "0" (a period, a capital letter X, or a digit zero).
Output
Print one of the six verdicts: first, second, illegal, the first player won, the second player won or draw.
Examples
Input
X0X
.0.
.X.
Output
second
|
first_row = input()
second_row = input()
third_row = input()
c = 0
o = 0
for i in range(0,3):
if first_row[i] == 'X':
c = c + 1
elif first_row[i] == '0':
o = o + 1
for i in range(0,3):
if second_row[i] == 'X':
c = c + 1
elif second_row[i] == '0':
o = o + 1
for i in range(0,3):
if third_row[i] == 'X':
c = c + 1
elif third_row[i] == '0':
o = o + 1
r = 0
if first_row[0] == "X" and second_row[1] == "X" and third_row[2] == "X":
r = 1+r
if first_row[0] == "X" and second_row[0] == "X" and third_row[0] =="X":
r = 1+r
if first_row[0] == "X" and first_row[1] == "X" and first_row[2]== "X":
r = 1+r
if first_row[1] == "X" and second_row[1] == "X" and third_row[1] == "X":
r = 1+r
if first_row[2] == "X" and second_row[2] == "X" and third_row[2] == "X":
r = 1+r
if first_row[2] == "X" and second_row[1] == "X" and third_row[0] == "X":
r = 1+r
if second_row[0] == "X" and second_row[1] == "X" and second_row[2] == "X":
r = r + 1
if third_row[0] == "X" and third_row[1] == "X" and third_row[2] == "X":
r = r + 1
q = 0
if first_row[0] == "0" and second_row[1] == "0" and third_row[2] == "0":
q = 1+q
if first_row[0] == "0" and second_row[0] == "0" and third_row[0] =="0":
q = 1+q
if first_row[0] == "0" and first_row[1] == "0" and first_row[2] == "0":
q = q + 1
if first_row[1] == "0" and second_row[1] == "0" and third_row[1]== "0":
q = 1 + q
if first_row[2] == "0" and second_row[2] == "0" and third_row[2] == "0":
q = 1 + q
if first_row[2] == "0" and second_row[1] == "0" and third_row[0] == "0":
q = 1 + q
if second_row[0] == "0" and second_row[1] == "0" and second_row[2] == "0":
q = q + 1
if third_row[0] == "0" and third_row[1] == "0" and third_row[2] == "0":
q = q + 1
if first_row[0] == "X" and first_row[2] == "X" and third_row[0] == "X" and third_row[2] == "X" and first_row[1] == "0" and second_row[0] == "0" and second_row[2] == "0" and third_row[1] == "0" and second_row[1] == "X":
print("the first player won")
elif first_row[0] == "X" and first_row[1] == "X" and third_row[2] == "X" and second_row[2] == "X" and second_row[1] == "0" and third_row[1] == "0" and third_row[0] == "0" and second_row[0] == "0" and first_row[2] == "X":
print("the first player won")
elif first_row[2] == "0" and first_row[1] == "0" and first_row[0] == "X" and second_row[2] == "0" and second_row[1] == "0" and third_row[1] == "X" and third_row[2] == "X" and second_row[0] == "X" and third_row[0] == "X":
print("the first player won")
elif first_row[2] == "0" and first_row[1] == "X" and first_row[0] == "0" and second_row[2] == "X" and second_row[0] == "X" and third_row[1] == "X" and third_row[2] == "0" and third_row[0] == "0" and second_row[1] == "X":
print("the first player won")
elif first_row[2] == "0" and first_row[1] == "0" and first_row[0] == "X" and second_row[2] == "X" and second_row[1] == "X" and third_row[1] == "0" and third_row[2] == "0" and third_row[0] == "X" and second_row[0] == "X":
print("the first player won")
elif first_row[2] == "X" and first_row[1] == "0" and first_row[0] == "0" and second_row[0] == "X" and second_row[1] == "X" and third_row[1] == "0" and third_row[2] == "X" and third_row[0] == "0" and second_row[2] == "X":
print("the first player won")
elif first_row[0] == "X" and first_row[1] == "X" and first_row[2] == "X" and second_row[2] == "0" and second_row[0] == "X" and second_row[2] == "0" and third_row[0] == "X" and third_row[1] == "0" and third_row[2] == "0":
print("the first player won")
elif c-o > 1 or (o-c) >= 1 or (r==1 and q == 1):
print("illegal")
elif q >= 1 and r == 0:
if c == o:
print("the second player won")
else:
print("illegal")
elif r >= 1 and q == 0:
if c-1 == o:
print("the first player won")
else:
print("illegal")
elif c - o == 1 and o+c != 9:
print("second")
elif c-o == 0:
print("first")
else:
print("draw")
|
Sereja has two sequences a1, a2, ..., an and b1, b2, ..., bm, consisting of integers. One day Sereja got bored and he decided two play with them. The rules of the game was very simple. Sereja makes several moves, in one move he can perform one of the following actions:
1. Choose several (at least one) first elements of sequence a (non-empty prefix of a), choose several (at least one) first elements of sequence b (non-empty prefix of b); the element of sequence a with the maximum index among the chosen ones must be equal to the element of sequence b with the maximum index among the chosen ones; remove the chosen elements from the sequences.
2. Remove all elements of both sequences.
The first action is worth e energy units and adds one dollar to Sereja's electronic account. The second action is worth the number of energy units equal to the number of elements Sereja removed from the sequences before performing this action. After Sereja performed the second action, he gets all the money that he earned on his electronic account during the game.
Initially Sereja has s energy units and no money on his account. What maximum number of money can Sereja get? Note, the amount of Seraja's energy mustn't be negative at any time moment.
Input
The first line contains integers n, m, s, e (1 ≤ n, m ≤ 105; 1 ≤ s ≤ 3·105; 103 ≤ e ≤ 104). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105). The third line contains m integers b1, b2, ..., bm (1 ≤ bi ≤ 105).
Output
Print a single integer — maximum number of money in dollars that Sereja can get.
Examples
Input
5 5 100000 1000
1 2 3 4 5
3 2 4 5 1
Output
3
Input
3 4 3006 1000
1 2 3
1 2 4 3
Output
2
|
#include <bits/stdc++.h>
using std::endl;
using std::make_pair;
using std::max;
using std::pair;
using std::set;
using std::upper_bound;
const int MAX_SEQ_SIZE = 100 * 1000;
const int MAX_NUM = 100 * 1000;
const int MAX_S = 300 * 1000;
const int MIN_E = 1000;
const int MAX_N = MAX_SEQ_SIZE;
const int MAX_M = MAX_SEQ_SIZE;
static int solve(const int nn, const int ss, const int ee, const int* arrA,
const set<pair<int, int> >& num2bi) {
static int dp[(MAX_S / MIN_E) + 2];
const int act_num = (ss / ee);
int bucks = 0;
const set<pair<int, int> >::const_iterator n2bi_e = num2bi.end();
for (int a_ind = 1; a_ind <= nn; ++a_ind) {
const int the_number = arrA[a_ind];
pair<int, int> n2bi_pair(the_number, 0);
for (int action_index = act_num, profit = act_num + 1; profit > 0;
--profit, --action_index) {
const int dp_curr = dp[action_index];
if (!dp_curr && action_index) continue;
n2bi_pair.second = dp_curr;
const set<pair<int, int> >::const_iterator n2bi_it =
num2bi.upper_bound(n2bi_pair);
if (n2bi_it == n2bi_e || n2bi_it->first != the_number) continue;
const int b_ind = n2bi_it->second;
if ((profit * ee) + a_ind + b_ind <= ss) bucks = max(bucks, profit);
int& dp_prev = dp[profit];
if (dp_prev == 0 || dp_prev > b_ind) dp_prev = b_ind;
}
}
return bucks;
}
int main(void) {
std::ios_base::sync_with_stdio(false);
using std::cin;
using std::cout;
if (!cin.good()) return 1;
int N, M, S, E;
cin >> N >> M >> S >> E;
static int arrA[MAX_N + 1];
for (int i = 1; i <= N; i++) cin >> arrA[i];
set<pair<int, int> > num2bi;
{
int num;
for (int i = 1; i <= M; i++) {
cin >> num;
num2bi.insert(make_pair(num, i));
}
}
if (!cin.eof() && !cin.good()) return 2;
const int ans = solve(N, S, E, arrA, num2bi);
cout << ans << endl;
return 0;
}
|
Alas, finding one's true love is not easy. Masha has been unsuccessful in that yet. Her friend Dasha told Masha about a way to determine the phone number of one's Prince Charming through arithmancy.
The phone number is divined like that. First one needs to write down one's own phone numbers. For example, let's suppose that Masha's phone number is 12345. After that one should write her favorite digit from 0 to 9 under the first digit of her number. That will be the first digit of the needed number. For example, Masha's favorite digit is 9. The second digit is determined as a half sum of the second digit of Masha's number and the already written down first digit from her beloved one's number. In this case the arithmetic average equals to (2 + 9) / 2 = 5.5. Masha can round the number up or down, depending on her wishes. For example, she chooses the digit 5. Having written down the resulting digit under the second digit of her number, Masha moves to finding the third digit in the same way, i.e. finding the half sum the the third digit of her number and the second digit of the new number. The result is (5 + 3) / 2 = 4. In this case the answer is unique. Thus, every i-th digit is determined as an arithmetic average of the i-th digit of Masha's number and the i - 1-th digit of her true love's number. If needed, the digit can be rounded up or down. For example, Masha can get:
12345 95444 Unfortunately, when Masha tried dialing the number, she got disappointed: as it turned out, the number was unavailable or outside the coverage area. But Masha won't give up. Perhaps, she rounded to a wrong digit or chose the first digit badly. That's why she keeps finding more and more new numbers and calling them. Count the number of numbers Masha calls. Masha calls all the possible numbers that can be found by the described means of arithmancy, except for, perhaps, her own one.
Input
The first line contains nonempty sequence consisting of digits from 0 to 9 — Masha's phone number. The sequence length does not exceed 50.
Output
Output the single number — the number of phone numbers Masha will dial.
Examples
Input
12345
Output
48
Input
09
Output
15
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class m6 {
static String s;
static int n;
static long DP[][][];
public static long call(int ind , int prev , int flag) {
if(ind==n && flag==0)
return 1;
if(ind==n)
return 0;
if(DP[ind][prev][flag]!=-1)
return DP[ind][prev][flag];
int a = s.charAt(ind)-'0';
int sum = a + prev;
if(sum%2 == 0) {
int dig = sum/2;
if(dig != (s.charAt(ind)-'0') && flag==1)
flag = 0;
return DP[ind][prev][flag] = call(ind+1,dig,flag);
}else {
int dig1 = sum/2;
int dig2 = (sum/2) + 1;
int flag1 = flag;
int flag2 = flag;
long res = 0;
if(dig1 != (s.charAt(ind)-'0') && flag1==1)
flag1 = 0;
res += call(ind+1,dig1,flag1);
if(dig2 != (s.charAt(ind)-'0') && flag2==1)
flag2 = 0;
res += call(ind+1,dig2,flag2);
return DP[ind][prev][flag] = res;
}
}
public static void main(String[] args) throws Exception {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
s = in.readLine();
n = s.length();
DP = new long [n][10][2];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 10; j++) {
for (int j2 = 0; j2 < 2; j2++) {
DP[i][j][j2] = -1;
}
}
}
long res = 0;
for (int i = 0; i < 10; i++) {
if(i==(s.charAt(0)-'0'))
res += call(1,i,1);
else
res += call(1,i,0);
}
System.out.println(res);
}
}
|
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev got hold of lots of wooden cubes somewhere. They started making cube towers by placing the cubes one on top of the other. They defined multiple towers standing in a line as a wall. A wall can consist of towers of different heights.
Horace was the first to finish making his wall. He called his wall an elephant. The wall consists of w towers. The bears also finished making their wall but they didn't give it a name. Their wall consists of n towers. Horace looked at the bears' tower and wondered: in how many parts of the wall can he "see an elephant"? He can "see an elephant" on a segment of w contiguous towers if the heights of the towers on the segment match as a sequence the heights of the towers in Horace's wall. In order to see as many elephants as possible, Horace can raise and lower his wall. He even can lower the wall below the ground level (see the pictures to the samples for clarification).
Your task is to count the number of segments where Horace can "see an elephant".
Input
The first line contains two integers n and w (1 ≤ n, w ≤ 2·105) — the number of towers in the bears' and the elephant's walls correspondingly. The second line contains n integers ai (1 ≤ ai ≤ 109) — the heights of the towers in the bears' wall. The third line contains w integers bi (1 ≤ bi ≤ 109) — the heights of the towers in the elephant's wall.
Output
Print the number of segments in the bears' wall where Horace can "see an elephant".
Examples
Input
13 5
2 4 5 5 4 3 2 2 2 3 3 2 1
3 4 4 3 2
Output
2
Note
The picture to the left shows Horace's wall from the sample, the picture to the right shows the bears' wall. The segments where Horace can "see an elephant" are in gray.
<image>
|
#include <bits/stdc++.h>
using namespace std;
int n, m, N, a[200500], b[200500], arr[200500 + 200500], z[200500 + 200500],
ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
if (n < m) {
cout << 0;
return 0;
}
if (m == 1) {
cout << n;
return 0;
}
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> b[i];
for (int i = 2; i <= m; i++) arr[N++] = b[i] - b[i - 1];
arr[N++] = 1 << 30;
for (int i = 2; i <= n; i++) arr[N++] = a[i] - a[i - 1];
for (int i = 1, l = 0, r = 0; i < N; i++) {
if (i <= r) z[i] = min(z[i - l], r - i + 1);
while (z[i] + i < N && arr[z[i]] == arr[z[i] + i]) z[i]++;
if (z[i] + i - 1 > r) l = i, r = z[i] + i - 1;
}
for (int i = m; i < N; i++) {
if (z[i] == m - 1) ans++;
}
cout << ans;
return 0;
}
|
Malek is a rich man. He also is very generous. That's why he decided to split his money between poor people. A charity institute knows n poor people numbered from 1 to n. The institute gave Malek q recommendations. A recommendation is a segment of people like [l, r] which means the institute recommended that Malek gives one dollar to every person whose number is in this segment.
However this charity has very odd rules about the recommendations. Because of those rules the recommendations are given in such a way that for every two recommendation [a, b] and [c, d] one of the following conditions holds:
* The two segments are completely disjoint. More formally either a ≤ b < c ≤ d or c ≤ d < a ≤ b
* One of the two segments are inside another. More formally either a ≤ c ≤ d ≤ b or c ≤ a ≤ b ≤ d.
The goodness of a charity is the value of maximum money a person has after Malek finishes giving his money. The institute knows for each recommendation what is the probability that Malek will accept it. They want to know the expected value of goodness of this charity. So they asked you for help.
You have been given the list of recommendations and for each recommendation the probability of it being accepted by Malek. You have also been given how much money each person initially has. You must find the expected value of goodness.
Input
In the first line two space-separated integers n, q (1 ≤ n ≤ 105, 1 ≤ q ≤ 5000) are given.
In the second line n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 109) are given meaning that person number i initially has ai dollars.
Each of the next q lines contains three space-separated numbers li, ri, pi (1 ≤ li ≤ ri ≤ n, 0 ≤ p ≤ 1) where li and ri are two integers describing the segment of recommendation and pi is a real number given with exactly three digits after decimal point which is equal to probability of Malek accepting this recommendation.
Note that a segment may appear several times in recommendations.
Output
Output the sought value. Your answer will be considered correct if its absolute or relative error is less than 10 - 6.
Examples
Input
5 2
1 7 2 4 3
1 3 0.500
2 2 0.500
Output
8.000000000
Input
5 2
281 280 279 278 282
1 4 1.000
1 4 0.000
Output
282.000000000
Input
3 5
1 2 3
1 3 0.500
2 2 0.250
1 2 0.800
1 1 0.120
2 2 0.900
Output
4.465000000
|
#include <bits/stdc++.h>
template <class T1, class T2, class Pred = std::less<T2> >
struct sort_pair_second {
bool operator()(const std::pair<T1, T2> &left,
const std::pair<T1, T2> &right) {
Pred p;
return p(left.second, right.second);
}
};
using namespace std;
struct sol_t {
int start, end;
vector<double> p;
vector<double> psum;
sol_t() {}
sol_t(int v) {
start = end = v;
p.push_back(1.0);
psum.push_back(1.0);
}
sol_t(sol_t &s1, sol_t &s2) {
start = max(s1.start, s2.start);
end = max(s1.end, s2.end);
p = vector<double>(end - start + 1);
psum = vector<double>(end - start + 1);
for (int v = start; v <= end; v++)
p[v - start] = s1.fetchp(v) * s2.fetchpsum(v - 1) +
s1.fetchpsum(v - 1) * s2.fetchp(v) +
s1.fetchp(v) * s2.fetchp(v);
update_psum();
}
double fetchp(int v) {
if (!(start <= v && v <= end)) return 0.0;
return p[v - start];
}
double fetchpsum(int v) {
if (v < start) return 0.0;
if (v > end) return 1.0;
return psum[v - start];
}
void update(double prob) {
end++;
p.push_back(0.0);
psum.push_back(-1);
for (int v = end - 1; v >= start; v--) {
p[v + 1 - start] += p[v - start] * prob;
p[v - start] *= (1 - prob);
}
update_psum();
}
void update_psum() {
for (int v = start; v <= end; v++) {
psum[v - start] = p[v - start];
if (v - 1 >= start) psum[v - start] += psum[v - 1 - start];
}
}
double expectation() {
double result = 0.0;
for (int v = start; v <= end; v++) {
result += v * p[v - start];
}
return result;
}
};
int values[100000];
struct range_t {
int a, b;
double prob;
int maxv;
vector<int> child;
sol_t solution;
bool operator<(const range_t &other) const {
if (a != other.a) return a < other.a;
return (b - a) > (other.b - other.a);
}
void populate(int &pos, int nr);
void solve();
} range[5000 + 1];
void range_t::populate(int &pos, int nr) {
while (pos < nr && range[pos].b <= this->b) {
this->child.push_back(pos);
pos++;
range[pos - 1].populate(pos, nr);
}
}
void range_t::solve() {
maxv = -1000000000;
if (child.empty()) {
for (int i = a; i <= b; i++) maxv = max(maxv, values[i]);
} else {
for (int i = a; i <= range[child.front()].a - 1; i++)
maxv = max(maxv, values[i]);
for (int k = 0; k + 1 < (int)child.size(); k++)
for (int i = range[child[k]].b + 1; i <= range[child[k + 1]].a - 1; i++)
maxv = max(maxv, values[i]);
for (int i = range[child.back()].b + 1; i <= b; i++)
maxv = max(maxv, values[i]);
}
solution = sol_t(maxv);
for (int c : child) {
range[c].solve();
solution = sol_t(solution, range[c].solution);
}
solution.update(prob);
}
int main() {
int n, nr;
scanf("%d %d", &n, &nr);
for (int i = 0; i < n; i++) scanf("%d", &values[i]);
for (int r = 0; r < nr; r++)
scanf("%d %d %lf", &range[r].a, &range[r].b, &range[r].prob), range[r].a--,
range[r].b--;
range[nr].a = 0, range[nr].b = n - 1, range[nr].prob = 0.0;
nr++;
sort(range, range + nr);
int pos = 1;
range[0].populate(pos, nr);
range[0].solve();
printf("%.8f\n", range[0].solution.expectation());
return 0;
}
|
The New Vasjuki village is stretched along the motorway and that's why every house on it is characterized by its shift relative to some fixed point — the xi coordinate. The village consists of n houses, the i-th house is located in the point with coordinates of xi.
TELE3, a cellular communication provider planned to locate three base stations so as to provide every house in the village with cellular communication. The base station having power d located in the point t provides with communication all the houses on the segment [t - d, t + d] (including boundaries).
To simplify the integration (and simply not to mix anything up) all the three stations are planned to possess the equal power of d. Which minimal value of d is enough to provide all the houses in the village with cellular communication.
Input
The first line contains an integer n (1 ≤ n ≤ 2·105) which represents the number of houses in the village. The second line contains the coordinates of houses — the sequence x1, x2, ..., xn of integer numbers (1 ≤ xi ≤ 109). It is possible that two or more houses are located on one point. The coordinates are given in a arbitrary order.
Output
Print the required minimal power d. In the second line print three numbers — the possible coordinates of the base stations' location. Print the coordinates with 6 digits after the decimal point. The positions of the stations can be any from 0 to 2·109 inclusively. It is accepted for the base stations to have matching coordinates. If there are many solutions, print any of them.
Examples
Input
4
1 2 3 4
Output
0.500000
1.500000 2.500000 3.500000
Input
3
10 20 30
Output
0
10.000000 20.000000 30.000000
Input
5
10003 10004 10001 10002 1
Output
0.500000
1.000000 10001.500000 10003.500000
|
import java.io.*;
import java.util.*;
public class ProblemC {
InputReader in; PrintWriter out;
int n;
double[] ans = new double[5];
boolean ok(int[] a, double r) {
double from = a[0] - 1e-8;
double to = a[0] + 2 * r + 1e-8;
ans[0] = from + r;
int k = 0;
while (k < n && a[k] <= to)
k++;
if (k == n)
return true;
from = a[k] - 1e-8;
to = a[k] + 2 * r + 1e-8;
ans[1] = from + r;
while (k < n && a[k] <= to)
k++;
if (k == n)
return true;
from = a[k] - 1e-8;
to = a[k] + 2 * r + 1e-8;
ans[2] = from + r;
while (k < n && a[k] <= to)
k++;
if (k == n)
return true;
return false;
}
void solve() {
n = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = in.nextInt();
Arrays.sort(a);
double lg = 0.0, rg = 1000000000.0, mi = 0;
while (rg - lg > 1e-10) {
mi = (lg + rg) / 2;
if (mi == lg || mi == rg)
break;
if (ok(a, mi))
rg = mi;
else
lg = mi;
}
ok(a, rg);
out.printf("%.6f\n", rg);
for (int i = 0; i < 3; i++) {
if (ans[i] > 2000000000.0)
ans[i] = 2000000000.0;
out.printf("%.6f ", ans[i]);
}
}
ProblemC(){
boolean oj = System.getProperty("ONLINE_JUDGE") != null;
try {
if (oj) {
in = new InputReader(System.in);
out = new PrintWriter(System.out);
}
else {
Writer w = new FileWriter("output.txt");
in = new InputReader(new FileReader("input.txt"));
out = new PrintWriter(w);
}
} catch(Exception e) {
throw new RuntimeException(e);
}
solve();
out.close();
}
public static void main(String[] args){
new ProblemC();
}
}
class InputReader {
private BufferedReader reader;
private StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
public InputReader(FileReader fr) {
reader = new BufferedReader(fr);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
|
Two soldiers are playing a game. At the beginning first of them chooses a positive integer n and gives it to the second soldier. Then the second one tries to make maximum possible number of rounds. Each round consists of choosing a positive integer x > 1, such that n is divisible by x and replacing n with n / x. When n becomes equal to 1 and there is no more possible valid moves the game is over and the score of the second soldier is equal to the number of rounds he performed.
To make the game more interesting, first soldier chooses n of form a! / b! for some positive integer a and b (a ≥ b). Here by k! we denote the factorial of k that is defined as a product of all positive integers not large than k.
What is the maximum possible score of the second soldier?
Input
First line of input consists of single integer t (1 ≤ t ≤ 1 000 000) denoting number of games soldiers play.
Then follow t lines, each contains pair of integers a and b (1 ≤ b ≤ a ≤ 5 000 000) defining the value of n for a game.
Output
For each game output a maximum score that the second soldier can get.
Examples
Input
2
3 1
6 3
Output
2
5
|
#include <bits/stdc++.h>
using namespace std;
int prime[5000001];
void SieveOfEratosthenes() {
int i, p;
for (i = 2; i < 5000001; i += 2) prime[i] = 2;
for (p = 3; p < 5000001; p += 2) {
if (!(prime[p])) {
prime[p] = p;
for (i = p * 3; i < 5000001; i += (2 * p)) prime[i] = p;
}
}
}
int aux[5000001], res[5000001];
int main() {
SieveOfEratosthenes();
int i, t, a, b;
aux[1] = 0;
for (i = 2; i < 5000001; i++) {
aux[i] = aux[i / prime[i]] + 1;
res[i] = res[i - 1] + aux[i];
}
scanf("%d", &t);
for (i = 0; i < t; i++) {
scanf("%d%d", &b, &a);
printf("%d\n", res[b] - res[a]);
}
}
|
Limak is an old brown bear. He often plays poker with his friends. Today they went to a casino. There are n players (including Limak himself) and right now all of them have bids on the table. i-th of them has bid with size ai dollars.
Each player can double his bid any number of times and triple his bid any number of times. The casino has a great jackpot for making all bids equal. Is it possible that Limak and his friends will win a jackpot?
Input
First line of input contains an integer n (2 ≤ n ≤ 105), the number of players.
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109) — the bids of players.
Output
Print "Yes" (without the quotes) if players can make their bids become equal, or "No" otherwise.
Examples
Input
4
75 150 75 50
Output
Yes
Input
3
100 150 250
Output
No
Note
In the first sample test first and third players should double their bids twice, second player should double his bid once and fourth player should both double and triple his bid.
It can be shown that in the second sample test there is no way to make all bids equal.
|
import java.util.Scanner;
import java.util.Arrays;
public class Main{
public static void main(String[] args){
Scanner kb = new Scanner(System.in);
int n = kb.nextInt();
int[] c = new int[n];
for(int i = 0 ; i < n ; i++){
c[i] = kb.nextInt();
}
int[] m = new int[n];
for(int i = 0, j = 0 ; i < n ; i++){
while(c[i] % 3 == 0)
c[i] /= 3;
while(c[i] % 2 == 0)
c[i] /= 2;
m[j++] = c[i];
}
boolean jp = true;
for(int i = 1 ; i < n ; i++){
if (m[i] != m[0]){
jp = false;
break;
}
}
if (jp)
System.out.println("Yes");
else
System.out.println("No");
}
}
|
Today on a math lesson the teacher told Vovochka that the Euler function of a positive integer φ(n) is an arithmetic function that counts the positive integers less than or equal to n that are relatively prime to n. The number 1 is coprime to all the positive integers and φ(1) = 1.
Now the teacher gave Vovochka an array of n positive integers a1, a2, ..., an and a task to process q queries li ri — to calculate and print <image> modulo 109 + 7. As it is too hard for a second grade school student, you've decided to help Vovochka.
Input
The first line of the input contains number n (1 ≤ n ≤ 200 000) — the length of the array given to Vovochka. The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106).
The third line contains integer q (1 ≤ q ≤ 200 000) — the number of queries. Next q lines contain the queries, one per line. Each query is defined by the boundaries of the segment li and ri (1 ≤ li ≤ ri ≤ n).
Output
Print q numbers — the value of the Euler function for each query, calculated modulo 109 + 7.
Examples
Input
10
1 2 3 4 5 6 7 8 9 10
7
1 1
3 8
5 6
4 8
8 10
7 9
7 10
Output
1
4608
8
1536
192
144
1152
Input
7
24 63 13 52 6 10 1
6
3 5
4 7
1 7
2 4
3 6
2 6
Output
1248
768
12939264
11232
9984
539136
Note
In the second sample the values are calculated like that:
* φ(13·52·6) = φ(4056) = 1248
* φ(52·6·10·1) = φ(3120) = 768
* φ(24·63·13·52·6·10·1) = φ(61326720) = 12939264
* φ(63·13·52) = φ(42588) = 11232
* φ(13·52·6·10) = φ(40560) = 9984
* φ(63·13·52·6·10) = φ(2555280) = 539136
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2 * int(1e9);
const long long INFll = 1ll * INF * INF;
const int MOD = 1000000007;
const int MAX_A = 1000001;
int lp[MAX_A];
vector<int> pr;
void findPrimes() {
for (int i = 2; i < MAX_A; ++i) {
if (!lp[i]) {
lp[i] = i;
pr.push_back(i);
}
for (int j = 0; j < pr.size() && pr[j] <= lp[i] && 1ll * pr[j] * i < MAX_A;
++j)
lp[pr[j] * i] = pr[j];
}
}
vector<int> fastFact(int x) {
vector<int> res;
while (x > 1) {
if (res.empty() || res.back() != lp[x]) res.push_back(lp[x]);
x /= lp[x];
}
return res;
}
vector<int> t;
int sz;
void modify(int x, int y) {
t[x] = y;
x /= 2;
while (x) {
t[x] = t[x * 2] * 1ll * t[x * 2 + 1] % MOD;
x /= 2;
}
}
int get(int v, int l, int r, int l1, int r1) {
if (l > r1 || r < l1) return 1;
if (l >= l1 && r <= r1) return t[v];
return get(v * 2, l, (l + r) / 2, l1, r1) * 1ll *
get(v * 2 + 1, (l + r) / 2 + 1, r, l1, r1) % MOD;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
findPrimes();
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
sz = 1;
while (sz < n) sz *= 2;
t.assign(sz * 2, 1);
for (int i = 0; i < n; ++i) modify(i + sz, a[i]);
int m;
cin >> m;
vector<pair<pair<int, int>, int> > q(m);
for (int i = 0; i < m; ++i)
cin >> q[i].first.first >> q[i].first.second, q[i].second = i;
sort(q.begin(), q.end());
vector<int> ans(m);
vector<vector<int> > pos(MAX_A);
vector<int> it(MAX_A, 1);
vector<vector<int> > x(MAX_A);
for (int i = 0; i < n; ++i) {
vector<int> tmp = fastFact(a[i]);
for (int j = 0; j < tmp.size(); ++j) {
pos[tmp[j]].push_back(i);
x[i].push_back(tmp[j]);
}
}
int j = 0;
for (int i = 0; i < MAX_A; ++i)
if (!pos[i].empty())
modify(sz + pos[i][0], t[sz + pos[i][0]] / i * (i - 1));
for (int i = 0; i < m; ++i) {
q[i].first.first--;
q[i].first.second--;
while (j < q[i].first.first) {
for (int i = 0; i < x[j].size(); ++i) {
int y = x[j][i];
if (pos[y].size() == it[y])
continue;
else {
modify(pos[y][it[y]] + sz, t[pos[y][it[y]] + sz] / y * (y - 1));
it[y]++;
}
}
j++;
}
ans[q[i].second] = get(1, 0, sz - 1, q[i].first.first, q[i].first.second);
}
for (int i = 0; i < m; ++i) cout << ans[i] << endl;
if (0) cerr << "\nTIME = " << clock() << "\n";
return 0;
}
|
Jack decides to invite Emma out for a dinner. Jack is a modest student, he doesn't want to go to an expensive restaurant. Emma is a girl with high taste, she prefers elite places.
Munhattan consists of n streets and m avenues. There is exactly one restaurant on the intersection of each street and avenue. The streets are numbered with integers from 1 to n and the avenues are numbered with integers from 1 to m. The cost of dinner in the restaurant at the intersection of the i-th street and the j-th avenue is cij.
Jack and Emma decide to choose the restaurant in the following way. Firstly Emma chooses the street to dinner and then Jack chooses the avenue. Emma and Jack makes their choice optimally: Emma wants to maximize the cost of the dinner, Jack wants to minimize it. Emma takes into account that Jack wants to minimize the cost of the dinner. Find the cost of the dinner for the couple in love.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 100) — the number of streets and avenues in Munhattan.
Each of the next n lines contains m integers cij (1 ≤ cij ≤ 109) — the cost of the dinner in the restaurant on the intersection of the i-th street and the j-th avenue.
Output
Print the only integer a — the cost of the dinner for Jack and Emma.
Examples
Input
3 4
4 1 3 5
2 2 2 2
5 4 5 1
Output
2
Input
3 3
1 2 3
2 3 1
3 1 2
Output
1
Note
In the first example if Emma chooses the first or the third streets Jack can choose an avenue with the cost of the dinner 1. So she chooses the second street and Jack chooses any avenue. The cost of the dinner is 2.
In the second example regardless of Emma's choice Jack can choose a restaurant with the cost of the dinner 1.
|
import math
n=raw_input().split()
t=[]
for i in range(int(n[0])):
a=raw_input().split()
mini=int(a[0])
for i in a:
if mini>int(i):
mini=int(i)
t.append(mini)
print max(t)
|
Two positive integers a and b have a sum of s and a bitwise XOR of x. How many possible values are there for the ordered pair (a, b)?
Input
The first line of the input contains two integers s and x (2 ≤ s ≤ 1012, 0 ≤ x ≤ 1012), the sum and bitwise xor of the pair of positive integers, respectively.
Output
Print a single integer, the number of solutions to the given conditions. If no solutions exist, print 0.
Examples
Input
9 5
Output
4
Input
3 3
Output
2
Input
5 2
Output
0
Note
In the first sample, we have the following solutions: (2, 7), (3, 6), (6, 3), (7, 2).
In the second sample, the only solutions are (1, 2) and (2, 1).
|
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long s, x;
cin >> s >> x;
int delta = 2 * (s == x);
unsigned long long s1x1 = ((s & 1) << 1) | (x & 1);
unsigned long long c0 = (s1x1 == 0) + 2 * (s1x1 == 3);
unsigned long long c1 = s1x1 == 0;
for (int k = 0; k < 60; k++) {
x >>= 1;
s >>= 1;
unsigned long long sx = ((s & 1) << 1) | (x & 1);
unsigned long long d0, d1;
if (sx == 0) {
d0 = d1 = c0;
} else if (sx == 1) {
d0 = 0;
d1 = 2 * c1;
} else if (sx == 2) {
d0 = d1 = c1;
} else {
d0 = 2 * c0;
d1 = 0;
}
c0 = d0;
c1 = d1;
}
cout << c0 - delta;
}
|
You are given a rebus of form ? + ? - ? + ? = n, consisting of only question marks, separated by arithmetic operation '+' and '-', equality and positive integer n. The goal is to replace each question mark with some positive integer from 1 to n, such that equality holds.
Input
The only line of the input contains a rebus. It's guaranteed that it contains no more than 100 question marks, integer n is positive and doesn't exceed 1 000 000, all letters and integers are separated by spaces, arithmetic operations are located only between question marks.
Output
The first line of the output should contain "Possible" (without quotes) if rebus has a solution and "Impossible" (without quotes) otherwise.
If the answer exists, the second line should contain any valid rebus with question marks replaced by integers from 1 to n. Follow the format given in the samples.
Examples
Input
? + ? - ? + ? + ? = 42
Output
Possible
9 + 13 - 39 + 28 + 31 = 42
Input
? - ? = 1
Output
Impossible
Input
? = 1000000
Output
Possible
1000000 = 1000000
|
#include <bits/stdc++.h>
using namespace std;
vector<char> v;
int maxn = 200;
int main() {
int u[maxn];
string c = "?";
int x = 0, y = 1, n = 0, sum;
v.push_back('+');
while (c == "?" || c == "+" || c == "-" || c == "=") {
cin >> c;
if (c == "-") {
x++;
v.push_back('-');
}
if (c == "+") {
y++;
v.push_back('+');
}
}
for (int i = 0; i < c.size(); i++) {
n *= 10;
n += c[i] - '0';
}
if (n < y - (x * n) || n > y * n - x) {
cout << "Impossible";
return 0;
} else
cout << "Possible\n";
for (int i = 0; i <= 200; i++) u[i] = 1;
sum = y - x;
for (int i = 0; i < x + y && sum != n; i++) {
if (sum > n) {
while (v[i] != '-') i++;
u[i] += min(sum - n, n - 1);
sum -= min(sum - n, n - 1);
}
if (sum < n) {
while (v[i] != '+') i++;
u[i] += min(n - sum, n - 1);
sum += min(n - sum, n - 1);
}
}
for (int i = 0; i < x + y; i++) {
if (i + 1 != x + y)
cout << u[i] << " " << (char)v[i + 1] << " ";
else
cout << u[i] << " ";
}
printf("= %d", n);
}
|
Pari wants to buy an expensive chocolate from Arya. She has n coins, the value of the i-th coin is ci. The price of the chocolate is k, so Pari will take a subset of her coins with sum equal to k and give it to Arya.
Looking at her coins, a question came to her mind: after giving the coins to Arya, what values does Arya can make with them? She is jealous and she doesn't want Arya to make a lot of values. So she wants to know all the values x, such that Arya will be able to make x using some subset of coins with the sum k.
Formally, Pari wants to know the values x such that there exists a subset of coins with the sum k such that some subset of this subset has the sum x, i.e. there is exists some way to pay for the chocolate, such that Arya will be able to make the sum x using these coins.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 500) — the number of coins and the price of the chocolate, respectively.
Next line will contain n integers c1, c2, ..., cn (1 ≤ ci ≤ 500) — the values of Pari's coins.
It's guaranteed that one can make value k using these coins.
Output
First line of the output must contain a single integer q— the number of suitable values x. Then print q integers in ascending order — the values that Arya can make for some subset of coins of Pari that pays for the chocolate.
Examples
Input
6 18
5 6 1 10 12 2
Output
16
0 1 2 3 5 6 7 8 10 11 12 13 15 16 17 18
Input
3 50
25 25 50
Output
3
0 25 50
|
#include <bits/stdc++.h>
const long long mod = 1e9 + 7;
void fail() {
std::cout << "NO\n";
exit(0);
}
using namespace std;
const long long N = 502;
long long n, k, a[N];
bool dp[502][502][502];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
dp[1][a[1]][0] = 1;
dp[1][0][a[1]] = 1;
dp[1][0][0] = 1;
for (long long i = 2; i <= n; i++) {
dp[i][0][0] = 1;
for (long long j = 0; j <= k; j++) {
for (long long s = 0; s <= k; s++) {
dp[i][j][s] = dp[i - 1][j][s];
if (j >= a[i]) dp[i][j][s] = max(dp[i][j][s], dp[i - 1][j - a[i]][s]);
if (s >= a[i]) dp[i][j][s] = max(dp[i][j][s], dp[i - 1][j][s - a[i]]);
}
}
}
vector<long long> ans;
for (long long s = 0; s <= k; s++) {
if (dp[n][s][k - s] || dp[n][k - s][s]) ans.push_back(s);
}
cout << ans.size() << '\n';
for (long long i : ans) cout << i << ' ';
cout << '\n';
return 0;
}
|
You are given two arithmetic progressions: a1k + b1 and a2l + b2. Find the number of integers x such that L ≤ x ≤ R and x = a1k' + b1 = a2l' + b2, for some integers k', l' ≥ 0.
Input
The only line contains six integers a1, b1, a2, b2, L, R (0 < a1, a2 ≤ 2·109, - 2·109 ≤ b1, b2, L, R ≤ 2·109, L ≤ R).
Output
Print the desired number of integers x.
Examples
Input
2 0 3 3 5 21
Output
3
Input
2 4 3 0 6 17
Output
2
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10240000,10240000")
using namespace std;
const double R = 0.5772156649015328606065120900;
const int N = 50 + 5;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1.0);
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long ex_gcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
long long d = ex_gcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
long long inverse(long long a, long long mod) {
long long x, y;
if (ex_gcd(a, mod, x, y) != 1) return -1;
return (x % mod + mod) % mod;
}
bool Merge(long long a1, long long m1, long long a2, long long m2,
long long &ansa, long long &ansm) {
long long c = a2 - a1, d = gcd(m1, m2);
if (c % d) return false;
c = (c % m2 + m2) % m2;
long long A = c / d * inverse(m1 / d, m2 / d);
A %= m2 / d;
long long tmp_a = m1 * A + a1;
ansm = m1 / d * m2;
ansa = (tmp_a % ansm + ansm) % ansm;
return true;
}
int main() {
long long a1, b1, a2, b2, le, ri;
scanf("%I64d%I64d%I64d%I64d%I64d%I64d", &a1, &b1, &a2, &b2, &le, &ri);
long long a, m;
if (!Merge(b1, a1, b2, a2, a, m)) {
puts("0");
return 0;
}
le = max(le, max(b1, b2));
if (le > ri)
puts("0");
else {
long long c1 = double(le - a) / m;
bool tag = false;
for (long long i = c1 - 4; i <= c1 + 4; i++) {
long long tm = i * m + a;
if (tm >= le && tm <= ri) {
c1 = i;
tag = true;
break;
}
}
if (!tag) {
puts("0");
return 0;
}
long long c2 = double(ri - a) / m;
tag = false;
for (long long i = c2 + 4; i >= c2 - 4; i--) {
long long tm = i * m + a;
if (tm <= ri && tm >= le) {
c2 = i;
tag = true;
break;
}
}
if (!tag) {
puts("0");
return 0;
}
long long ans = c2 - c1 + 1;
if (ans < 0)
puts("0");
else
printf("%I64d\n", ans);
}
return 0;
}
|
Archeologists have found a secret pass in the dungeon of one of the pyramids of Cycleland. To enter the treasury they have to open an unusual lock on the door. The lock consists of n words, each consisting of some hieroglyphs. The wall near the lock has a round switch. Each rotation of this switch changes the hieroglyphs according to some rules. The instruction nearby says that the door will open only if words written on the lock would be sorted in lexicographical order (the definition of lexicographical comparison in given in notes section).
The rule that changes hieroglyphs is the following. One clockwise rotation of the round switch replaces each hieroglyph with the next hieroglyph in alphabet, i.e. hieroglyph x (1 ≤ x ≤ c - 1) is replaced with hieroglyph (x + 1), and hieroglyph c is replaced with hieroglyph 1.
Help archeologist determine, how many clockwise rotations they should perform in order to open the door, or determine that this is impossible, i.e. no cyclic shift of the alphabet will make the sequence of words sorted lexicographically.
Input
The first line of the input contains two integers n and c (2 ≤ n ≤ 500 000, 1 ≤ c ≤ 106) — the number of words, written on the lock, and the number of different hieroglyphs.
Each of the following n lines contains the description of one word. The i-th of these lines starts with integer li (1 ≤ li ≤ 500 000), that denotes the length of the i-th word, followed by li integers wi, 1, wi, 2, ..., wi, li (1 ≤ wi, j ≤ c) — the indices of hieroglyphs that make up the i-th word. Hieroglyph with index 1 is the smallest in the alphabet and with index c — the biggest.
It's guaranteed, that the total length of all words doesn't exceed 106.
Output
If it is possible to open the door by rotating the round switch, print integer x (0 ≤ x ≤ c - 1) that defines the required number of clockwise rotations. If there are several valid x, print any of them.
If it is impossible to open the door by this method, print - 1.
Examples
Input
4 3
2 3 2
1 1
3 2 3 1
4 2 3 1 2
Output
1
Input
2 5
2 4 2
2 4 2
Output
0
Input
4 4
1 2
1 3
1 4
1 2
Output
-1
Note
Word a1, a2, ..., am of length m is lexicographically not greater than word b1, b2, ..., bk of length k, if one of two conditions hold:
* at first position i, such that ai ≠ bi, the character ai goes earlier in the alphabet than character bi, i.e. a has smaller character in the first position where they differ;
* if there is no such position i and m ≤ k, i.e. the first word is a prefix of the second or two words are equal.
The sequence of words is said to be sorted in lexicographical order if each word (except the last one) is lexicographically not greater than the next word.
In the first sample, after the round switch is rotated 1 position clockwise the words look as follows:
1 3
2
3 1 2
3 1 2 3
In the second sample, words are already sorted in lexicographical order.
In the last sample, one can check that no shift of the alphabet will work.
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5e5 + 5;
const long long inf = 0x3f3f3f3f;
int a[2][maxn], num[maxn * 2];
int n, c;
void update(int l, int r) {
num[l]++;
num[r + 1]--;
}
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
int i, j, l, r, ans, tmpl, tmpr, tmp, tag = 1, t = 0;
cin >> n >> c;
cin >> a[1 % 2][0];
for (j = 1; j <= a[1 % 2][0]; j++) {
cin >> a[1 % 2][j];
}
for (i = 2; i <= n; i++) {
cin >> a[i % 2][0];
for (j = 1; j <= a[i % 2][0]; j++) {
cin >> a[i % 2][j];
}
if (tag) {
for (j = 1; j <= min(a[i % 2][0], a[(i - 1) % 2][0]); j++) {
if (a[i % 2][j] > a[(i - 1) % 2][j]) {
t++;
update(0, c - a[i % 2][j]);
update(c - a[(i - 1) % 2][j] + 1, c - 1);
break;
}
if (a[i % 2][j] < a[(i - 1) % 2][j]) {
tmpl = c - a[(i - 1) % 2][j] + 1;
tmpr = c - a[i % 2][j];
t++;
update(tmpl, tmpr);
break;
}
}
if (j > min(a[i % 2][0], a[(i - 1) % 2][0])) {
if (a[i % 2][0] < a[(i - 1) % 2][0]) {
tag = 0;
}
}
}
}
for (i = 1; i <= c - 1; i++) {
num[i] += num[i - 1];
}
ans = -1;
if (tag) {
for (i = 0; i <= c - 1; i++) {
if (t == num[i]) {
ans = i;
break;
}
}
}
cout << ans << endl;
return 0;
}
|
It's Christmas time! PolandBall and his friends will be giving themselves gifts. There are n Balls overall. Each Ball has someone for whom he should bring a present according to some permutation p, pi ≠ i for all i.
Unfortunately, Balls are quite clumsy. We know earlier that exactly k of them will forget to bring their gift. A Ball number i will get his present if the following two constraints will hold:
1. Ball number i will bring the present he should give.
2. Ball x such that px = i will bring his present.
What is minimum and maximum possible number of kids who will not get their present if exactly k Balls will forget theirs?
Input
The first line of input contains two integers n and k (2 ≤ n ≤ 106, 0 ≤ k ≤ n), representing the number of Balls and the number of Balls who will forget to bring their presents.
The second line contains the permutation p of integers from 1 to n, where pi is the index of Ball who should get a gift from the i-th Ball. For all i, pi ≠ i holds.
Output
You should output two values — minimum and maximum possible number of Balls who will not get their presents, in that order.
Examples
Input
5 2
3 4 1 5 2
Output
2 4
Input
10 1
2 3 4 5 6 7 8 9 10 1
Output
2 2
Note
In the first sample, if the third and the first balls will forget to bring their presents, they will be th only balls not getting a present. Thus the minimum answer is 2. However, if the first ans the second balls will forget to bring their presents, then only the fifth ball will get a present. So, the maximum answer is 4.
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:32000000")
using namespace std;
inline bool read(int& val) { return scanf("%d", &val) != -1; }
inline bool read(long long& val) { return scanf("%I64d", &val) != -1; }
inline bool read(double& val) { return scanf("%lf", &val) != -1; }
inline bool read(char* val) { return scanf("%s", val) != -1; }
template <class T1, class T2>
inline bool read(T1& a, T2& b) {
return read(a) && read(b);
}
template <class T1, class T2, class T3>
inline bool read(T1& a, T2& b, T3& c) {
return read(a) && read(b) && read(c);
}
template <class T1, class T2, class T3, class T4>
inline bool read(T1& a, T2& b, T3& c, T4& d) {
return read(a) && read(b) && read(c) && read(d);
}
template <class T1, class T2, class T3, class T4, class T5>
inline bool read(T1& a, T2& b, T3& c, T4& d, T5& e) {
return read(a) && read(b) && read(c) && read(d) && read(e);
}
const int N = 1111111;
const long long mod = 1000000007;
int A[N];
int cnt[N];
bool vis[N];
bitset<N> dp;
int main() {
int n, k;
read(n, k);
for (int i = 1, _ = (n); i <= _; ++i) read(A[i]);
int odd = 0;
for (int i = 1, _ = (n); i <= _; ++i) {
int len = 0;
for (int j = i; !vis[j]; j = A[j]) len += (vis[j] = true);
cnt[len]++;
odd += len % 2;
}
for (int i = 1, _ = (n); i <= _; ++i)
while (cnt[i] > 2) {
cnt[i * ((cnt[i] + 1) / 2)]++;
cnt[i] /= 2;
}
dp[0] = 1;
for (int i = 1, _ = (n); i <= _; ++i)
for (int j = 0, _ = (cnt[i]); j < _; ++j) dp |= dp << i;
cout << (dp[k] ? k : k + 1) << ' ';
if (k * 2 <= n - odd)
cout << k * 2 << endl;
else
cout << min(n, k + (n - odd) / 2) << endl;
return 0;
}
|
Sherlock found a piece of encrypted data which he thinks will be useful to catch Moriarty. The encrypted data consists of two integer l and r. He noticed that these integers were in hexadecimal form.
He takes each of the integers from l to r, and performs the following operations:
1. He lists the distinct digits present in the given number. For example: for 101416, he lists the digits as 1, 0, 4.
2. Then he sums respective powers of two for each digit listed in the step above. Like in the above example sum = 21 + 20 + 24 = 1910.
3. He changes the initial number by applying bitwise xor of the initial number and the sum. Example: <image>. Note that xor is done in binary notation.
One more example: for integer 1e the sum is sum = 21 + 214. Letters a, b, c, d, e, f denote hexadecimal digits 10, 11, 12, 13, 14, 15, respertively.
Sherlock wants to count the numbers in the range from l to r (both inclusive) which decrease on application of the above four steps. He wants you to answer his q queries for different l and r.
Input
First line contains the integer q (1 ≤ q ≤ 10000).
Each of the next q lines contain two hexadecimal integers l and r (0 ≤ l ≤ r < 1615).
The hexadecimal integers are written using digits from 0 to 9 and/or lowercase English letters a, b, c, d, e, f.
The hexadecimal integers do not contain extra leading zeros.
Output
Output q lines, i-th line contains answer to the i-th query (in decimal notation).
Examples
Input
1
1014 1014
Output
1
Input
2
1 1e
1 f
Output
1
0
Input
2
1 abc
d0e fe23
Output
412
28464
Note
For the second input,
1416 = 2010
sum = 21 + 24 = 18
<image>
Thus, it reduces. And, we can verify that it is the only number in range 1 to 1e that reduces.
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0;
char c = getchar();
bool f = 0;
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
if (f) return -sum;
return sum;
}
const int Z = 65535;
long long f[17][Z + 1][16];
bool vis[17][Z + 1][16];
inline long long dp(int p, int l, int K) {
if (vis[p][l][K]) return f[p][l][K];
vis[p][l][K] = 1;
if (!p) return f[p][l][K] = ((l >> K) & 1);
int i;
long long r = 0;
for (i = 0; i <= 15; i++) r += dp(p - 1, ((l << 4) | i) & Z, max(K, i));
return f[p][l][K] = r;
}
char s[20];
inline long long _gets() {
int i, x, y;
long long r = 0;
scanf("%s", s + 1);
for (x = strlen(s + 1), i = 1; i <= x; i++) {
if (s[i] >= '0' && s[i] <= '9')
y = s[i] - '0';
else
y = s[i] - 'a' + 10;
r = (r << 4) | y;
}
return r;
}
int n, S[20];
inline long long ask(long long v) {
if (v <= 0) return 0;
int i, j, K = 0, l = 0;
long long r = 0;
for (n = 0; v; v >>= 4) S[++n] = v & 15;
for (i = n; i >= 1; i--) {
for (j = 0; j < S[i]; j++) r += f[i - 1][((l << 4) | j) & Z][max(K, j)];
l <<= 4;
l |= S[i];
l &= Z;
K = max(K, S[i]);
}
return r + f[0][l][K];
}
inline void work() {
int T = read();
long long l, r;
while (T--) {
l = _gets();
r = _gets();
printf("%I64d\n", ask(r) - ask(l - 1));
}
}
int main() {
dp(16, 0, 0);
work();
return 0;
}
|
You have n devices that you want to use simultaneously.
The i-th device uses ai units of power per second. This usage is continuous. That is, in λ seconds, the device will use λ·ai units of power. The i-th device currently has bi units of power stored. All devices can store an arbitrary amount of power.
You have a single charger that can plug to any single device. The charger will add p units of power per second to a device. This charging is continuous. That is, if you plug in a device for λ seconds, it will gain λ·p units of power. You can switch which device is charging at any arbitrary unit of time (including real numbers), and the time it takes to switch is negligible.
You are wondering, what is the maximum amount of time you can use the devices until one of them hits 0 units of power.
If you can use the devices indefinitely, print -1. Otherwise, print the maximum amount of time before any one device hits 0 power.
Input
The first line contains two integers, n and p (1 ≤ n ≤ 100 000, 1 ≤ p ≤ 109) — the number of devices and the power of the charger.
This is followed by n lines which contain two integers each. Line i contains the integers ai and bi (1 ≤ ai, bi ≤ 100 000) — the power of the device and the amount of power stored in the device in the beginning.
Output
If you can use the devices indefinitely, print -1. Otherwise, print the maximum amount of time before any one device hits 0 power.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 4.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
2 1
2 2
2 1000
Output
2.0000000000
Input
1 100
1 1
Output
-1
Input
3 5
4 3
5 2
6 1
Output
0.5000000000
Note
In sample test 1, you can charge the first device for the entire time until it hits zero power. The second device has enough power to last this time without being charged.
In sample test 2, you can use the device indefinitely.
In sample test 3, we can charge the third device for 2 / 5 of a second, then switch to charge the second device for a 1 / 10 of a second.
|
#include <bits/stdc++.h>
using namespace std;
long double a[100005], b[100005], p;
int n;
bool chk(long double x) {
long double xa = p * x;
long double yb = 0;
for (int i = 0; i < n; i++) {
if ((a[i] * x) > b[i]) yb += ((a[i] * x) - b[i]);
}
if (xa >= yb)
return 1;
else
return 0;
}
long double t_search() {
int cnt = 0;
long double lo = 0.000001, hi = 1000000000000000000.0, A, B, ans;
while (cnt < 70) {
A = (2 * lo + hi) / 3;
B = (2 * hi + lo) / 3;
if (chk(B)) {
lo = A;
ans = B;
} else if (chk(A)) {
hi = B;
ans = A;
} else
hi = A;
cnt++;
}
return ans;
}
int main() {
long double tot;
while (cin >> n >> p) {
tot = 0;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i], tot += a[i];
if (p >= tot)
cout << -1 << endl;
else
cout << t_search() << endl;
}
return 0;
}
|
Okabe likes to take walks but knows that spies from the Organization could be anywhere; that's why he wants to know how many different walks he can take in his city safely. Okabe's city can be represented as all points (x, y) such that x and y are non-negative. Okabe starts at the origin (point (0, 0)), and needs to reach the point (k, 0). If Okabe is currently at the point (x, y), in one step he can go to (x + 1, y + 1), (x + 1, y), or (x + 1, y - 1).
Additionally, there are n horizontal line segments, the i-th of which goes from x = ai to x = bi inclusive, and is at y = ci. It is guaranteed that a1 = 0, an ≤ k ≤ bn, and ai = bi - 1 for 2 ≤ i ≤ n. The i-th line segment forces Okabe to walk with y-value in the range 0 ≤ y ≤ ci when his x value satisfies ai ≤ x ≤ bi, or else he might be spied on. This also means he is required to be under two line segments when one segment ends and another begins.
Okabe now wants to know how many walks there are from the origin to the point (k, 0) satisfying these conditions, modulo 109 + 7.
Input
The first line of input contains the integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 1018) — the number of segments and the destination x coordinate.
The next n lines contain three space-separated integers ai, bi, and ci (0 ≤ ai < bi ≤ 1018, 0 ≤ ci ≤ 15) — the left and right ends of a segment, and its y coordinate.
It is guaranteed that a1 = 0, an ≤ k ≤ bn, and ai = bi - 1 for 2 ≤ i ≤ n.
Output
Print the number of walks satisfying the conditions, modulo 1000000007 (109 + 7).
Examples
Input
1 3
0 3 3
Output
4
Input
2 6
0 3 0
3 10 2
Output
4
Note
<image>
The graph above corresponds to sample 1. The possible walks are:
* <image>
* <image>
* <image>
* <image>
<image>
The graph above corresponds to sample 2. There is only one walk for Okabe to reach (3, 0). After this, the possible walks are:
* <image>
* <image>
* <image>
* <image>
|
#include <bits/stdc++.h>
using namespace std;
const long long base = 1e9 + 7;
long long n, k;
struct line {
long long a, b, y;
} a[101];
struct matrix {
long long val[16][16];
matrix() { memset(val, 0, sizeof(val)); }
};
struct matran {
long long val[16];
matran() { memset(val, 0, sizeof(val)); }
};
matrix res, tmp, A;
matran cur;
inline matrix operator*(const matrix &x, const matrix &y) {
for (int i = 0; i <= 15; i++) {
for (int j = 0; j <= 15; j++) {
tmp.val[i][j] = 0;
for (int p = 0; p <= 15; p++) {
tmp.val[i][j] =
(tmp.val[i][j] + (x.val[i][p] * y.val[p][j]) % base) % base;
}
}
}
return tmp;
}
inline matran operator*(const matrix &x, const matran &y) {
for (int i = 0; i <= 15; i++) {
cur.val[i] = 0;
for (int j = 0; j <= 15; j++) {
cur.val[i] = (cur.val[i] + (x.val[i][j] * y.val[j]) % base) % base;
}
}
return cur;
}
inline void pw(long long p) {
if (p == 1) {
res = A;
return;
}
for (int i = 0; i <= 15; i++) res.val[i][i] = 1;
for (; p; p /= 2, A = A * A) {
if (p & 1) res = res * A;
}
}
matran B, ans;
matrix duc;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i].a >> a[i].b >> a[i].y;
}
B.val[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 15; j++) {
if (j > a[i].y) B.val[j] = 0;
}
if (a[i].a >= k) break;
for (int p = 0; p <= 15; p++) {
for (int q = 0; q <= 15; q++) {
A.val[p][q] = 0;
}
}
for (int j = a[i].y; j >= 0; j--) {
if (j + 1 <= a[i].y) A.val[j][j + 1] = 1;
A.val[j][j] = 1;
if (j - 1 >= 0) A.val[j][j - 1] = 1;
}
memset(res.val, 0, sizeof(res.val));
if (a[i].b >= k)
pw(k - a[i].a);
else
pw(a[i].b - a[i].a);
B = res * B;
}
cout << B.val[0];
}
|
A game field is a strip of 1 × n square cells. In some cells there are Packmen, in some cells — asterisks, other cells are empty.
Packman can move to neighboring cell in 1 time unit. If there is an asterisk in the target cell then Packman eats it. Packman doesn't spend any time to eat an asterisk.
In the initial moment of time all Packmen begin to move. Each Packman can change direction of its move unlimited number of times, but it is not allowed to go beyond the boundaries of the game field. Packmen do not interfere with the movement of other packmen; in one cell there can be any number of packmen moving in any directions.
Your task is to determine minimum possible time after which Packmen can eat all the asterisks.
Input
The first line contains a single integer n (2 ≤ n ≤ 105) — the length of the game field.
The second line contains the description of the game field consisting of n symbols. If there is symbol '.' in position i — the cell i is empty. If there is symbol '*' in position i — in the cell i contains an asterisk. If there is symbol 'P' in position i — Packman is in the cell i.
It is guaranteed that on the game field there is at least one Packman and at least one asterisk.
Output
Print minimum possible time after which Packmen can eat all asterisks.
Examples
Input
7
*..P*P*
Output
3
Input
10
.**PP.*P.*
Output
2
Note
In the first example Packman in position 4 will move to the left and will eat asterisk in position 1. He will spend 3 time units on it. During the same 3 time units Packman in position 6 will eat both of neighboring with it asterisks. For example, it can move to the left and eat asterisk in position 5 (in 1 time unit) and then move from the position 5 to the right and eat asterisk in the position 7 (in 2 time units). So in 3 time units Packmen will eat all asterisks on the game field.
In the second example Packman in the position 4 will move to the left and after 2 time units will eat asterisks in positions 3 and 2. Packmen in positions 5 and 8 will move to the right and in 2 time units will eat asterisks in positions 7 and 10, respectively. So 2 time units is enough for Packmen to eat all asterisks on the game field.
|
#include <bits/stdc++.h>
using namespace std;
string s;
vector<int> p;
bool check(int x) {
int ind = 0, i = 0;
while (1) {
while (ind < s.size() && s[ind] != '*') ind++;
if (ind >= s.size()) return true;
if (i >= p.size()) return false;
if (ind < p[i]) {
if (p[i] - ind > x) return false;
int t = p[i] - ind;
ind = max(ind, p[i] + 1 + max(0, x - 2 * (p[i] - ind)));
ind = max(ind, p[i] + ((x - t) / 2) + 1);
} else
ind = max(p[i] + x + 1, ind);
i++;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, ans = 1e9, i;
cin >> n >> s;
int l = 0, r = 1e6;
for (i = 0; i < s.size(); i++) {
if (s[i] == 'P') p.push_back(i);
}
while (r - l > 1) {
int mid = (r + l) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
ans = min(ans, r);
cout << ans;
}
|
The prehistoric caves of El Toll are located in Moià (Barcelona). You have heard that there is a treasure hidden in one of n possible spots in the caves. You assume that each of the spots has probability 1 / n to contain a treasure.
You cannot get into the caves yourself, so you have constructed a robot that can search the caves for treasure. Each day you can instruct the robot to visit exactly k distinct spots in the caves. If none of these spots contain treasure, then the robot will obviously return with empty hands. However, the caves are dark, and the robot may miss the treasure even when visiting the right spot. Formally, if one of the visited spots does contain a treasure, the robot will obtain it with probability 1 / 2, otherwise it will return empty. Each time the robot searches the spot with the treasure, his success probability is independent of all previous tries (that is, the probability to miss the treasure after searching the right spot x times is 1 / 2x).
What is the expected number of days it will take to obtain the treasure if you choose optimal scheduling for the robot? Output the answer as a rational number modulo 109 + 7. Formally, let the answer be an irreducible fraction P / Q, then you have to output <image>. It is guaranteed that Q is not divisible by 109 + 7.
Input
The first line contains the number of test cases T (1 ≤ T ≤ 1000).
Each of the next T lines contains two integers n and k (1 ≤ k ≤ n ≤ 5·108).
Output
For each test case output the answer in a separate line.
Example
Input
3
1 1
2 1
3 2
Output
2
500000007
777777786
Note
In the first case the robot will repeatedly search in the only spot. The expected number of days in this case is 2. Note that in spite of the fact that we know the treasure spot from the start, the robot still has to search there until he succesfully recovers the treasure.
In the second case the answer can be shown to be equal to 7 / 2 if we search the two spots alternatively. In the third case the answer is 25 / 9.
|
#include <bits/stdc++.h>
long long n, k, p, mo, gc, t, c, answ;
int ttt;
long long gcd(long long x, long long y) {
if (y == 0)
return (x);
else
return (gcd(y, x % y));
}
long long mi(long long aa, long long bb) {
long long s = 1;
while (bb != 0) {
if ((bb % 2) == 1) s = (s * aa) % mo;
aa = (aa * aa) % mo;
bb = bb / 2;
}
return (s);
}
void ask(long long ni, long long ki, long long x, long long y, long long xi,
long long yi, long long sz, long long siz) {
if (ki == 1) {
long long li, ri, ai;
li = mi(x, ni - 1);
if ((x + mo) % mo == 1)
ri = (ni - 1) * y % mo;
else
ri = (li - 1) * mi(x - 1, mo - 2) % mo * y % mo;
ai = (xi * ri + yi) % mo * mi((1 - li * xi) % mo, mo - 2) % mo;
if ((x + mo) % mo == 1) {
answ = (answ + ni * ai % mo * siz) % mo;
answ = (answ + ((ni - 1) * ni / 2) % mo * y % mo * siz) % mo;
} else {
answ = (answ + (li * x - 1) % mo * mi(x - 1, mo - 2) % mo *
(ai + (y * mi(x - 1, mo - 2)) % mo) % mo * siz) %
mo;
answ = (answ - ni * mi(x - 1, mo - 2) % mo * y % mo * siz) % mo;
}
answ = (answ - ai * (siz - sz)) % mo;
} else {
long long li, ri, mm = ni / ki, m = ni % ki, yy, sz1, sz2, aa, bb;
li = mi(x, mm - 1);
if ((x + mo) % mo == 1) {
answ = (answ + ((mm + 1) * mm / 2) % mo * m % mo * y % mo * siz) % mo;
answ =
(answ + (mm * (mm - 1) / 2) % mo * (ki - m) % mo * y % mo * siz) % mo;
} else {
answ = (answ + (li * x - 1) % mo * mi(x - 1, 2 * mo - 4) % mo * (ki - m) %
mo * y % mo * siz) %
mo;
answ = (answ + ((li * x % mo) * x - 1) % mo * mi(x - 1, 2 * mo - 4) % mo *
m % mo * y % mo * siz) %
mo;
answ = (answ - ni * mi(x - 1, mo - 2) % mo * y % mo * siz) % mo;
}
if (x == 1) {
sz1 = sz + mm * siz;
sz2 = sz + (mm - 1) * siz;
} else {
sz1 = (sz + ((li * x % mo) * x - 1) % mo * siz % mo * mi(x - 1, mo - 2) -
siz) %
mo;
sz2 = (sz + (li * x - 1) % mo * siz % mo * mi(x - 1, mo - 2) - siz) % mo;
}
if ((x + mo) % mo == 1) {
ri = mm * y % mo;
yy = (mm - 1) * y % mo;
} else {
ri = (li * x - 1) % mo * mi(x - 1, mo - 2) % mo * y % mo;
;
yy = (li - 1) * mi(x - 1, mo - 2) % mo * y % mo;
}
aa = (li * xi % mo * x) % mo;
bb = (li * xi) % mo;
aa = mi(aa, mo - 2);
bb = mi(bb, mo - 2);
ask(ki, m, bb, (0 - yy * xi - yi) % mo * bb % mo, aa,
(0 - ri * xi - yi) % mo * aa % mo, sz1, sz2);
}
}
int main() {
scanf("%d", &ttt);
mo = 1000000007;
p = (mo + 1) / 2;
for (int iii = 1; iii <= ttt; iii++) {
scanf("%I64d%I64d", &n, &k);
gc = gcd(n, k);
n = n / gc;
k = k / gc;
answ = 0;
if (p != 1)
ask(n, k, 1, 1, 1 - p, 1, 1, 1);
else {
t = n / k;
answ = (t * (t + 1) / 2) % mo;
answ = answ * k % mo;
c = n % k;
answ = (answ + c * (t + 1)) % mo;
}
answ = answ % mo;
answ = (answ * mi(n, mo - 2)) % mo;
answ = (answ + mo) % mo;
printf("%I64d\n", answ);
}
}
|
Ralph is in the Binary Country. The Binary Country consists of n cities and (n - 1) bidirectional roads connecting the cities. The roads are numbered from 1 to (n - 1), the i-th road connects the city labeled <image> (here ⌊ x⌋ denotes the x rounded down to the nearest integer) and the city labeled (i + 1), and the length of the i-th road is Li.
Now Ralph gives you m queries. In each query he tells you some city Ai and an integer Hi. He wants to make some tours starting from this city. He can choose any city in the Binary Country (including Ai) as the terminal city for a tour. He gains happiness (Hi - L) during a tour, where L is the distance between the city Ai and the terminal city.
Ralph is interested in tours from Ai in which he can gain positive happiness. For each query, compute the sum of happiness gains for all such tours.
Ralph will never take the same tour twice or more (in one query), he will never pass the same city twice or more in one tour.
Input
The first line contains two integers n and m (1 ≤ n ≤ 106, 1 ≤ m ≤ 105).
(n - 1) lines follow, each line contains one integer Li (1 ≤ Li ≤ 105), which denotes the length of the i-th road.
m lines follow, each line contains two integers Ai and Hi (1 ≤ Ai ≤ n, 0 ≤ Hi ≤ 107).
Output
Print m lines, on the i-th line print one integer — the answer for the i-th query.
Examples
Input
2 2
5
1 8
2 4
Output
11
4
Input
6 4
2
1
1
3
2
2 4
1 3
3 2
1 7
Output
11
6
3
28
Note
Here is the explanation for the second sample.
Ralph's first query is to start tours from city 2 and Hi equals to 4. Here are the options:
* He can choose city 5 as his terminal city. Since the distance between city 5 and city 2 is 3, he can gain happiness 4 - 3 = 1.
* He can choose city 4 as his terminal city and gain happiness 3.
* He can choose city 1 as his terminal city and gain happiness 2.
* He can choose city 3 as his terminal city and gain happiness 1.
* Note that Ralph can choose city 2 as his terminal city and gain happiness 4.
* Ralph won't choose city 6 as his terminal city because the distance between city 6 and city 2 is 5, which leads to negative happiness for Ralph.
So the answer for the first query is 1 + 3 + 2 + 1 + 4 = 11.
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Asgar Javadov
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
FastWriter out = new FastWriter(outputStream);
TaskD solver = new TaskD();
solver.solve(1, in, out);
out.close();
}
static class TaskD {
int[][] all;
long[][] sum;
int[] L;
public void solve(int testNumber, InputReader in, FastWriter out) {
int n = in.nextInt();
int m = in.nextInt();
L = new int[n + 1];
System.arraycopy(in.readIntArray(n - 1), 0, L, 2, n - 1);
sum = new long[n + 1][];
all = new int[n + 1][];
dfs(1, n);
while (m-- > 0) {
int a = in.nextInt();
int h = in.nextInt();
out.println(query(a, h) + queryTree(a >> 1, h - L[a], a));
}
}
private long query(int a, long h) {
if (h <= 0) return 0L;
int low = 0, high = all[a].length - 1;
while (low <= high) {
int mid = low + high >> 1;
if (all[a][mid] >= h) {
high = mid - 1;
} else {
low = mid + 1;
}
}
long res = h;
if (high >= 0) res = h * (high + 1) - sum[a][high];
return res;
}
private long queryTree(int a, int h, int from) {
if (a <= 0 || h <= 0) return 0L;
int id = from == a << 1 ? a << 1 | 1 : a << 1;
return (id < L.length ? query(id, h - L[id]) : 0L) + queryTree(a >> 1, h - L[a], a) + h;
}
private void dfs(int v, int n) {
if (v * 2 > n) {
all[v] = new int[1];
sum[v] = new long[1];
return;
}
int leftSon = v << 1;
dfs(leftSon, n);
int rightSon = v << 1 | 1;
int pos = 1;
if (rightSon <= n) {
dfs(rightSon, n);
all[v] = new int[1 + all[leftSon].length + all[rightSon].length];
for (int i = 0, j = 0; i < all[leftSon].length && j < all[rightSon].length; ) {
int l = L[leftSon] + all[leftSon][i];
int r = L[rightSon] + all[rightSon][j];
if (l <= r) {
all[v][pos++] = l;
++i;
} else {
all[v][pos++] = r;
++j;
}
if (i == all[leftSon].length) {
for (; j < all[rightSon].length; ++j)
all[v][pos++] = L[rightSon] + all[rightSon][j];
}
if (j == all[rightSon].length) {
for (; i < all[leftSon].length; ++i)
all[v][pos++] = L[leftSon] + all[leftSon][i];
}
}
} else {
all[v] = new int[1 + all[leftSon].length];
for (int e : all[leftSon])
all[v][pos++] = e + L[leftSon];
}
sum[v] = new long[all[v].length];
long prev = 0L;
for (int i = 0; i < sum[v].length; ++i) {
sum[v][i] += prev + all[v][i];
prev = sum[v][i];
}
}
}
static class FastWriter extends PrintWriter {
public FastWriter(OutputStream outputStream) {
super(outputStream);
}
public FastWriter(Writer writer) {
super(writer);
}
public FastWriter(String filename) throws FileNotFoundException {
super(filename);
}
}
static class InputReader extends BufferedReader {
StringTokenizer tokenizer;
public InputReader(InputStream inputStream) {
super(new InputStreamReader(inputStream), 32768);
}
public InputReader(String filename) {
super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(readLine());
} catch (IOException e) {
throw new RuntimeException();
}
}
return tokenizer.nextToken();
}
public Integer nextInt() {
return Integer.valueOf(next());
}
public int[] readIntArray(int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++)
array[i] = nextInt();
return array;
}
}
}
|
Let's call an array a of size n coprime iff gcd(a1, a2, ..., an) = 1, where gcd is the greatest common divisor of the arguments.
You are given two numbers n and k. For each i (1 ≤ i ≤ k) you have to determine the number of coprime arrays a of size n such that for every j (1 ≤ j ≤ n) 1 ≤ aj ≤ i. Since the answers can be very large, you have to calculate them modulo 109 + 7.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 2·106) — the size of the desired arrays and the maximum upper bound on elements, respectively.
Output
Since printing 2·106 numbers may take a lot of time, you have to output the answer in such a way:
Let bi be the number of coprime arrays with elements in range [1, i], taken modulo 109 + 7. You have to print <image>, taken modulo 109 + 7. Here <image> denotes bitwise xor operation (^ in C++ or Java, xor in Pascal).
Examples
Input
3 4
Output
82
Input
2000000 8
Output
339310063
Note
Explanation of the example:
Since the number of coprime arrays is large, we will list the arrays that are non-coprime, but contain only elements in range [1, i]:
For i = 1, the only array is coprime. b1 = 1.
For i = 2, array [2, 2, 2] is not coprime. b2 = 7.
For i = 3, arrays [2, 2, 2] and [3, 3, 3] are not coprime. b3 = 25.
For i = 4, arrays [2, 2, 2], [3, 3, 3], [2, 2, 4], [2, 4, 2], [2, 4, 4], [4, 2, 2], [4, 2, 4], [4, 4, 2] and [4, 4, 4] are not coprime. b4 = 55.
|
#include <bits/stdc++.h>
using namespace std;
const long long mxDv = 7;
const long long mskDv = 1 << mxDv;
long long fpow(long long &a, long long b) {
if (b == 0) return 1;
if (b & 1) return (a * fpow(a, b ^ 1)) % 1000000007l;
long long d = fpow(a, b >> 1);
return (d * d) % 1000000007l;
}
void Solve() {
long long n, k;
cin >> n >> k;
vector<long long> primes(k + 1), pos(k + 1), pw(k + 1), df(mskDv), sgn(mskDv);
for (long long i = 1; i < mskDv; ++i) sgn[i] = sgn[i & (i - 1)] ^ 1;
primes[1] = 1;
for (long long i = 2; i <= k; ++i) {
if (primes[i] == 0) {
primes[i] = i;
for (long long j = i * i; j < primes.size(); j += i)
if (!primes[j]) primes[j] = i;
}
}
for (long long i = 1; i <= k; ++i) {
if (i == primes[i])
pw[i] = fpow(i, n);
else
pw[i] = (pw[primes[i]] * pw[i / primes[i]]) % 1000000007l;
}
long long ans = 0, cnt_diff = 0;
for (long long i = 1; i <= k; ++i) {
long long q = i;
long long sz = 0;
while (q != 1) {
long long d = primes[q];
df[1 << sz++] = d;
while (primes[q] == d) q /= d;
}
sz = 1 << sz;
for (long long j = 1, r = 0; j < sz; r = j & (j + 1), ++j) {
if (r) df[j] = df[r] * df[j ^ r];
cnt_diff += ((sgn[j] << 1) - 1) * (pw[pos[df[j]] + 1] - pw[pos[df[j]]]);
pos[df[j]]++;
if (cnt_diff < 0) cnt_diff += 1000000007l;
if (cnt_diff >= 1000000007l) cnt_diff -= 1000000007l;
}
long long sm = pw[i] - cnt_diff;
if (sm < 0) sm += 1000000007l;
ans += sm ^ i;
}
cout << ans % 1000000007l;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
Solve();
return 0;
}
|
As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are n planes on Earth, numbered from 1 to n, and the plane with number i likes the plane with number fi, where 1 ≤ fi ≤ n and fi ≠ i.
We call a love triangle a situation in which plane A likes plane B, plane B likes plane C and plane C likes plane A. Find out if there is any love triangle on Earth.
Input
The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of planes.
The second line contains n integers f1, f2, ..., fn (1 ≤ fi ≤ n, fi ≠ i), meaning that the i-th plane likes the fi-th.
Output
Output «YES» if there is a love triangle consisting of planes on Earth. Otherwise, output «NO».
You can output any letter in lower case or in upper case.
Examples
Input
5
2 4 5 1 3
Output
YES
Input
5
5 5 5 5 1
Output
NO
Note
In first example plane 2 likes plane 4, plane 4 likes plane 1, plane 1 likes plane 2 and that is a love triangle.
In second example there are no love triangles.
|
n=int(input())
a=list(map(int,input().split()))
for i in range(n):
if a[a[a[i]-1]-1]==i+1:
print('YES')
exit(0)
print('NO')
|
You are given two integers a and b. Moreover, you are given a sequence s_0, s_1, ..., s_{n}. All values in s are integers 1 or -1. It's known that sequence is k-periodic and k divides n+1. In other words, for each k ≤ i ≤ n it's satisfied that s_{i} = s_{i - k}.
Find out the non-negative remainder of division of ∑ _{i=0}^{n} s_{i} a^{n - i} b^{i} by 10^{9} + 9.
Note that the modulo is unusual!
Input
The first line contains four integers n, a, b and k (1 ≤ n ≤ 10^{9}, 1 ≤ a, b ≤ 10^{9}, 1 ≤ k ≤ 10^{5}).
The second line contains a sequence of length k consisting of characters '+' and '-'.
If the i-th character (0-indexed) is '+', then s_{i} = 1, otherwise s_{i} = -1.
Note that only the first k members of the sequence are given, the rest can be obtained using the periodicity property.
Output
Output a single integer — value of given expression modulo 10^{9} + 9.
Examples
Input
2 2 3 3
+-+
Output
7
Input
4 1 5 1
-
Output
999999228
Note
In the first example:
(∑ _{i=0}^{n} s_{i} a^{n - i} b^{i}) = 2^{2} 3^{0} - 2^{1} 3^{1} + 2^{0} 3^{2} = 7
In the second example:
(∑ _{i=0}^{n} s_{i} a^{n - i} b^{i}) = -1^{4} 5^{0} - 1^{3} 5^{1} - 1^{2} 5^{2} - 1^{1} 5^{3} - 1^{0} 5^{4} = -781 ≡ 999999228 \pmod{10^{9} + 9}.
|
import java.util.*;
import java.math.*;
import java.io.*;
public class CF964C implements Runnable {
final int MOD = (int) 1e9 + 9; // weird modulo
final double ERROR = 1e-9;
final double oo = 1e50;
long invA, c;
public void run() {
FastScanner scan = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int n = scan.nextInt();
int a = scan.nextInt();
int b = scan.nextInt();
int k = scan.nextInt();
invA = modInv(a);
c = (modExp(invA, k) * modExp(b, k)) % MOD;
char[] s = scan.next().toCharArray();
long res = 0;
for(int i = 0 ; i < s.length ; i++) {
if(s[i] == '+') {
res += solve(i, k, n, a, b);
if(res >= MOD)
res -= MOD;
} else {
res -= solve(i, k, n, a, b);
if(res < 0)
res += MOD;
}
}
out.println(res);
out.close();
}
long solve(int i, int k, int n, long a, long b) {
long f0 = (modExp(a, n - i) * modExp(b, i)) % MOD;
long[][] mat1 = {{1, 1},
{0, c}};
long[][] mat2 = {{ 0},
{f0}};
mat1 = matExp(mat1, (n + 1) / k);
mat2 = mult2x1(mat1, mat2);
return mat2[0][0];
}
long modInv(long x) {
return modExp(x, MOD - 2);
}
long modExp(long b, long e) {
if(e == 0)
return 1L;
if((e & 1) == 0) {
long tmp = modExp(b, e / 2);
return (tmp * tmp) % MOD;
} else {
return (b * modExp(b, e - 1)) % MOD;
}
}
long[][] identity = {{1, 0},
{0, 1}};
long[][] matExp(long[][] m, long exp) {
if(exp == 0L)
return identity;
if((exp & 1) == 0) {
long[][] res = matExp(m, exp/2);
return mult2x2(res, res);
}
return mult2x2(m, matExp(m, exp-1));
}
long[][] mat2x2 = new long[2][2];
long[][] mult2x2(long[][] a, long[][] b) {
mat2x2[0][0] = (((a[0][0] * b[0][0]) % MOD) + ((a[1][0] * b[0][1]) % MOD));
if(mat2x2[0][0] >= MOD) mat2x2[0][0] += MOD;
mat2x2[0][1] = (((a[0][1] * b[0][0]) % MOD) + ((a[1][1] * b[0][1]) % MOD));
if(mat2x2[0][1] >= MOD) mat2x2[0][1] += MOD;
mat2x2[1][0] = (((a[0][0] * b[1][0]) % MOD) + ((a[1][0] * b[1][1]) % MOD));
if(mat2x2[1][0] >= MOD) mat2x2[1][0] += MOD;
mat2x2[1][1] = (((a[0][1] * b[1][0]) % MOD) + ((a[1][1] * b[1][1]) % MOD));
if(mat2x2[1][1] >= MOD) mat2x2[1][1] += MOD;
return mat2x2;
}
long[][] mat2x1 = new long[2][1];
long[][] mult2x1(long[][] a, long[][] b) {
mat2x1[0][0] = (((b[0][0] * a[0][0]) % MOD) + ((b[1][0] * a[0][1]) % MOD));
if(mat2x1[0][0] >= MOD) mat2x1[0][0] += MOD;
mat2x1[1][0] = (((b[0][0] * a[1][0]) % MOD) + ((b[1][0] * a[1][1]) % MOD));
if(mat2x1[1][0] >= MOD) mat2x1[1][0] += MOD;
return mat2x1;
}
class FastScanner {
BufferedReader br; StringTokenizer st;
public FastScanner() {
try {
br = new BufferedReader(new InputStreamReader(System.in));
st = new StringTokenizer(br.readLine());
} catch (Exception e){e.printStackTrace();}
}
public String next() {
if (st.hasMoreTokens()) return st.nextToken();
try {st = new StringTokenizer(br.readLine());}
catch (Exception e) {e.printStackTrace();}
return st.nextToken();
}
public int nextInt() {return Integer.parseInt(next());}
public long nextLong() {return Long.parseLong(next());}
public double nextDouble() {return Double.parseDouble(next());}
public String nextLine() {
String line = "";
if(st.hasMoreTokens()) line = st.nextToken();
else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
while(st.hasMoreTokens()) line += " "+st.nextToken();
return line;
}
}
public static void main(String[] args) {
new Thread(null, new CF964C(), "_cf", 1 << 28).start();
}
}
/*
8 2 3 3
-+-
8 2 3 9
-+--+--+-
3 2 3 4
+-+-
3 2 3 2
+-
*/
|
Bishwock is a chess figure that consists of three squares resembling an "L-bar". This figure can be rotated by 90, 180 and 270 degrees so it can have four possible states:
XX XX .X X.
X. .X XX XX
Bishwocks don't attack any squares and can even occupy on the adjacent squares as long as they don't occupy the same square.
Vasya has a board with 2× n squares onto which he wants to put some bishwocks. To his dismay, several squares on this board are already occupied by pawns and Vasya can't put bishwocks there. However, pawns also don't attack bishwocks and they can occupy adjacent squares peacefully.
Knowing the positions of pawns on the board, help Vasya to determine the maximum amount of bishwocks he can put onto the board so that they wouldn't occupy the same squares and wouldn't occupy squares with pawns.
Input
The input contains two nonempty strings that describe Vasya's board. Those strings contain only symbols "0" (zero) that denote the empty squares and symbols "X" (uppercase English letter) that denote the squares occupied by pawns. Strings are nonempty and are of the same length that does not exceed 100.
Output
Output a single integer — the maximum amount of bishwocks that can be placed onto the given board.
Examples
Input
00
00
Output
1
Input
00X00X0XXX0
0XXX0X00X00
Output
4
Input
0X0X0
0X0X0
Output
0
Input
0XXX0
00000
Output
2
|
def main():
a, b = [i for i in input()], [i for i in input()]
l = len(a)
c = 0
for i in range(l - 1):
if a[i] == '0':
if b[i] == '0':
if a[i + 1] == '0':
c += 1
a[i], b[i], a[i + 1] = 1, 1, 1
elif b[i + 1] == '0':
c += 1
a[i], b[i], b[i + 1] = 1, 1, 1
elif a[i + 1] == '0' and b[i + 1] == '0':
c += 1
a[i], a[i + 1], b[i + 1] = 1, 1, 1
elif b[i] == '0' and b[i + 1] == '0' and a[i + 1] == '0':
c += 1
b[i], a[i + 1], b[i + 1] = 1, 1, 1
print(c)
return 0
main()
|
Arjit, Protector of The Realm, has an important task at hand. M new subjects are soon going to become a part of The Realm. The Realm, though, already has N subjects who are well skilled in the ways of The Realm. He wants the new subjects too to become perfect in the ways.
As any Protector would, Arjit also decides that the existing subjects should train the new subjects in the ways. What's so special about this situation though? Each current subject of The Realm has a special skill Sc and he has reached a level of proficiency Pc at this. Every new subject of The Realm feels his favorite skill he would like to have is ** Sn** and reach a proficiency ** Pn** at it.
Let's call a current subject Foo and a new subject Bar. Foo can train Bar if Foo's special skill is the same one that Bar feels is his favorite. This is what we call a good pair. If Foo's special skill and Bar's favorite skill are the same and also Foo's proficiency is the same that Bar wants to achieve, we call it a great combination.
Let A be the number of good pairs and B be the number of great combinations. Arjit would like to maximize the number of new subjects to be trained by current subjects, i.e., number of good pairs. And, after maximizing number the number of good pairs, he wishes to maximize the number of great combinations.
Arjit wishes to have at least G good pairs and at least H great combinations.
If only the good pairs criteria is met, print "Good" (without quotes).
If both criterion are met, print "Great" (without quotes).
Else, print ":(" (without quotes).
Input:
The first line of input contains T. T test cases follow.
The first line of each test case has two integers, M and N.
In the following M lines, there are two integers on each line, U and V denoting favorite skill and proficiency they wish to obtain.
In the N lines that follow, there are two integers on each line, W and X denoting the special skill and the level of proficiency that has been reached.
The last line of each test case has two integers, G and H.
Output:
Print "Good", "Great" or ":(" (without quotes) on a new line for each test case.
Constraints:
1 ≤ T ≤ 10
1 ≤ M, N ≤ 10 ^5
1 ≤ U, V, W, X ≤ 10^4
1 ≤ G, H ≤ 10^5
See the example to understand better.
SAMPLE INPUT
1
2 2
1 1
2 3
1 1
2 3
2 2
SAMPLE OUTPUT
Great
Explanation
You have 2 new subjects and 2 current members of the realm.
Each new member is perfectly matched with an existing member of the realm.
So, good pair count is 2 and great combination count is also 2.
So, the output is "Great" (without quotes).
|
T = int(raw_input())
for _ in xrange(T):
M, N = map(int,raw_input().split())
A = [0]*M
B = [0]*N
for i in xrange(M):
u,v = map(int,raw_input().split())
A[i] = (u,v)
for i in xrange(N):
w,x = map(int,raw_input().split())
B[i] = (w,x)
g,h = map(int,raw_input().split())
aa = a1 = dict()
bb = b1 = dict()
for i in A:
x=i[0]
y=i[1]
if x not in a1:
a1[x] = 1
else:
a1[x] += 1
if i not in aa:
aa[i] = 1
else:
aa[i] += 1
for i in B:
x=i[0]
y=i[1]
if x not in b1:
b1[x] = 1
else:
b1[x] += 1
if i not in bb:
bb[i] = 1
else:
bb[i] += 1
gg = hh = 0
for x in a1:
if x in b1:
gg += min(a1[x],b1[x])
for i in aa:
if i in bb:
hh += min(aa[i],bb[i])
if gg >= g:
if hh >= h:
print "Great"
else:
print "Good"
else:
print ":("
|
How many different ways can you make change for an amount, given a list of coins? In this problem, your code will need to efficiently compute the answer.
Task
Write a program that, given
An amount N and types of infinite available coins M.
A list of M coins - C={C1,C2,C3,..,CM}
Prints out how many different ways you can make change from the coins to STDOUT.
The problem can be formally stated:
Given a value N, if we want to make change for N cents, and we have infinite supply of each of C={C1,C2,…,CM} valued coins, how many ways can we make the change? The order of coins doesn’t matter.
Constraints
1≤Ci≤50
1≤N≤250
1≤M≤50
The list of coins will contain distinct integers.
Input Format
First line will contain 2 integer N and M respectively.
Second line contain M integer that represent list of distinct coins that are available in infinite amount.
Output Format
One integer which is the number of ways in which we can get a sum of N from the given infinite supply of M types of coins.
SAMPLE INPUT
4 3
1 2 3
SAMPLE OUTPUT
4
Explanation
For N=4 and C={1,2,3} there are four solutions: {1,1,1,1},{1,1,2},{2,2},{1,3}
|
sl = raw_input().split()
N,M = (int(sl[0]),int(sl[1]))
lis = map(int,raw_input().split())
arr = [[0]*M for _ in xrange(N+1)]
for i in xrange(M):
arr[0][i] = 1
for i in range(1,N+1):
for j in xrange(M):
x = arr[i-lis[j]][j] if i-lis[j] >=0 else 0
y = arr[i][j-1] if j>0 else 0
arr[i][j] = x+y
print arr[N][M-1]
|
Nimbus, the techical festival of NIT Hanirpur is coming and thus Arun, the core-cordinator of departmental team of CSE, decided a conduct a game. In this game, the participant will be given a natural number N and will be asked T questions of form Type K.
Here Type denotes the type of question asked and K denotes a natural number.
If Type=1, the participant must find the number of natural numbers which is divisor of both N and K.
If Type=2, the participant must find the number of natural numbers which is divisor of N and is divisible by K.
If Type=3, the participant must find the number of natural numbers which is divisor of N and is not divisible by K.
As it will be very difficult for Arun to tell manually whether the asnwer given by participant is correct or not. So, he decided so write a code for it. As Arun is very busy for NIMBUS preparations, he has given this task to you.
INPUT
The first line of input contains 2 integers N and T, denoting the natural number and the number of questions asked respectively.
The next T lines contains 2 integers Type and K, denoting the Type of question asked and the natural number respectively.
OUTPUT
For each test case output a single integer (one per line), that is the answer to the question.
CONSTRAINTS
1 ≤ N ≤ 10^12
1 ≤ T ≤ 5*10^5
1 ≤ Type ≤ 3
1 ≤ K ≤ 10^12
SAMPLE INPUT
12 6
1 6
1 14
2 4
2 3
3 12
3 14
SAMPLE OUTPUT
4
2
2
3
5
6
Explanation
Divisors for each question asked:
{1,2,3,6}
{1,2}
{4,12}
{3,6,12}
{1,2,3,4,6}
{1,2,3,4,6,12}
|
import math
N, noOfQueries = raw_input().split(" ")
N, noOfQueries = int(N), int(noOfQueries)
upperLimit = int(math.sqrt(N))
divisors = []
for i in range(1, upperLimit + 1):
if(N % i == 0):
divisors.append(N/i)
divisors.append(i)
for q in range(1, noOfQueries + 1):
t, k = raw_input().split(" ")
t, k = int(t), int(k)
output = 0
if(t == 1):
for div in divisors:
if(k % div == 0):
output += 1
elif(t == 2):
for div in divisors:
if(div % k == 0):
output += 1
else:
for div in divisors:
if(div % k != 0):
output += 1
print output
|
Ramesh and Suresh are best friends. But they are fighting over money now. Suresh has given some money to Ramesh but he has forgotten how much money he had given. So Ramesh made a plan that he will give Re. 1 to every rectangle Suresh makes in a N x M area. Since Suresh is poor in mathematics he needs your help to make maximum possible rectangles in N x M area. You need to tell Suresh the maximum amount of money he can take back.
Input:
First line of the input contains T denoting the number of test cases. Then T lines follow each contains
two integers N and M.
Output:
Output the required answer for each test case in a separate line.
Constraints:
1 ≤ T ≤ 10^5
1 ≤ N, M ≤ 10^4
Sample Input:
2
1 2
3 3
Sample Output:
3
36
Explanation:
Test case: 2
3 x 3 area amount earned is Rs. 36
There are following:-
9 rectangles (1 x 1 area),
6 rectangles (1 x 2 area),
3 rectangles (1 x 3 area),
6 rectangles (2 x 1 area),
3 rectangles (3 x 1 area),
4 rectangles (2 x 2 area),
2 rectangles (2 x 3 area),
2 rectangles (3 x 2 area),
1 rectangle (3 x 3 area)SAMPLE INPUT
2
1 2
3 3
SAMPLE OUTPUT
3
36
|
t=input()
while t:
n,m=map(int,raw_input().split())
print ((n*(n+1))/2)*(m*(m+1)/2)
t-=1
|
Little Syed loves brute force. He thinks that brute force can be the solution to any problem in the world. You give him any question, and he'll have a brute force answer ready for you, almost all the time. His good friend Little Jhool (Like, always!) decides to teach him a lesson, by giving him problems which cannot be solved by brute force, because he wants Syed to learn algorithms.
Given a number, n, Syed needs to find the number closest to n, though less than n which satisfies Jhool's swinging theorem.
Jhool's swinging Theorem: A number n, such that it can be expressed as a sum of two positive algebraic cubes; AND, if that number can be expressed in such a manner in more than one way - it satisfies the theorem.
Now, everyone here on HackerEarth knows how much we hate Little Jhool (No, not really!) - so we want you to help Syed in figuring out Jhool's queries - once and for all!
Input Format:
The first line contains an integer, t - denoting the number of test cases.
The next t lines will contain, an integer - n - denoting the number which Jhool gives.
Output Format:
You have to print the previous number satisfying the given constraints. If no such previous number exists, print -1.
Constraints:
1 ≤ t ≤ 100
1 ≤ n ≤ 704977
SAMPLE INPUT
2
100
4150
SAMPLE OUTPUT
-1
4104
Explanation
In the first case, since no such number below 100 exists, the result is -1.
In the second case, 4104 is the answer because: (4096 + 8 = 4104) or (161616 + 222) and (3375 + 729 = 4104) or (151515 + 999) - that is, there is more than one way in which 4104 can be expressed, satisfying the theorem.
|
tc = input()
sloane_list = [1729, 4104, 13832, 20683, 32832, 39312, 40033, 46683, 64232, 65728, 110656, 110808, 134379, 149389, 165464, 171288, 195841, 216027, 216125, 262656, 314496, 320264, 327763, 373464, 402597, 439101, 443889, 513000, 513856, 515375, 525824, 558441, 593047, 684019, 704977]
for i in range(0,tc):
num = input()
if (num < 1729):
print "-1"
else:
for i in sloane_list:
if(i<num):
temp = i
else:
break
print temp
|
Given two integers, L and R, find the maximal value of A xor B,
where A and B satisfy the following condition:
L ≤ A ≤ B ≤ R
Input Format:
First line contains T,number of test cases
following T lines containing 2 intergers L and R ; L is present in the first line and R in
the second line.
Output Format:
T lines containing the maximal value as mentioned in the problem statement.
Constraints:
1≤L≤R≤103
SAMPLE INPUT
1
10 15
SAMPLE OUTPUT
7
Explanation
The input tells us that L=10 and R=15. All the pairs which comply
to above condition are the following:
10⊕10=0
10⊕11=1
10⊕12=6
10⊕13=7
10⊕14=4
10⊕15=5
11⊕11=0
11⊕12=7
11⊕13=6
11⊕14=5
11⊕15=4
12⊕12=0
12⊕13=1
12⊕14=2
12⊕15=3
13⊕13=0
13⊕14=3
13⊕15=2
14⊕14=0
14⊕15=1
15⊕15=0
Here two pairs (10, 13) and (11, 12) have maximum xor value 7, and
this is the answer.
|
t=int(raw_input())
while t:
t-=1
m=0
l,r=map(int,raw_input().split())
for i in xrange(l,r+1):
for j in xrange(i,r+1):
m=max(m,i^j)
print m
|
Pranav just learned about Modulus(%) and trying to solve a problem on Modulus but he always get TLE. Your task is to help him. Problem is simple, you have been given two numbers A and M and you have to find A%M and print it.
Input Format
Firstline: T, where T is the number of test cases. Now T line followed, Where each line consist of A and M space separated.
Constraints :
1 ≤T ≤ 100
Number of digit in A ≤ 5×10^5
1 ≤ M ≤ 10^9
Output Format
Print A%M in a new line.
Sample Input
2
12344 12
12 123
Sample Output
8
12
NOTE Only C/C++ is allowed for this challenge.
SAMPLE INPUT
2
12344 12
12 123
SAMPLE OUTPUT
8
12
|
t=int(raw_input())
while t>0:
m,n=map(int,raw_input().split())
print(m%n)
t-=1
|
One day Samu went out for a walk in the park but there weren't any of her friends with her. So she decided to enjoy by her own. Samu noticed that she was walking in rectangular field of size N x M (units). So field can be divided into N horizontal rows, each containing M unit size squares. The squares have coordinates (X, Y) (1 ≤ X ≤ N , 1 ≤ Y ≤ M) , where X is the index of the row and y is the index of the column.
Samu is initially standing at (1, 1). Also she is having a deck of K cards. Cards have a number written on top and a number written on bottom too. These numbers tell the direction to move. It means if she is currently at some coordinate (X, Y) and value on top of card is A and on bottom of the card is B then she jumps to (X+A, Y+B).
Game is played with following rules :
1. She looks all cards in the order from 1 to K and consecutively chooses each card as the current one.
2. After she had chosen a current card , she makes the maximally possible number of valid jumps with the chosen card.
She had been jumping for so long that she completely forgot how many jumps she had made. Help her count how many jumps she had made.
Input :
The first line contains number of test cases T. The first input line of each test case contains two space separated integers N and M, the park dimensions. The second line of each test case contains an integer K denoting the number of cards. Then follow K lines, each of them contains two integers A and B.
Output :
A single integer for each test case, The number of jumps Samu had made.
Constraints :
1 ≤ T ≤ 500
1 ≤ n, m ≤ 1000000000
1 ≤ K ≤ 10000
|A|,|B| ≤ 1000000000
|A|+|B| ≥ 1
SAMPLE INPUT
1
5 6
3
1 1
1 1
0 -4
SAMPLE OUTPUT
5
Explanation
Samu is initially positioned at square (1,1) and makes 4 steps by the first card (1,1).
So, she jumps in following sequence (1,1) => (2,2) => (3,3) => (4,4) => (5,5) .
No more Jumps can be made with this card so now she discard this card and moves to next one.
Then she makes 0 jumps by the second card (1,1).
She makes 1 more Jump by the third card (0,-4) and she ends up in square (5,1).
So she make 5 jumps in total.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
print 'Hello World!'
'''
t = int(raw_input())
for i in range (t):
n,m=map(int,raw_input().split())
k=int(raw_input())
res=0
x,y=1,1
for j in range(k):
a,b=map(int,raw_input().split())
if a>0:
xstep=(n-x)/a
elif a==0:
xstep=1000000001
else:
xstep=(x-1)/(-a)
if b>0:
ystep=(m-y)/b
elif b==0:
ystep=1000000001
else:
ystep=(y-1)/(-b)
step=min(xstep,ystep)
res=res+step
x=x+(step*a)
y=y+(step*b)
print res
|
Calculate the sum of the series :
INPUT:
First line contains the number of test cases t, for each test case a single line representing m and n with two space separated integers.
OUTPUT:
For each test case, a single line representing thee sum of the series in the form of p/q.
Constraints:
1 ≤ t ≤ 100
1 ≤ m, n ≤ 30
SAMPLE INPUT
1
2 3
SAMPLE OUTPUT
31/224
|
def gcd(x, y):
while y != 0:
(x, y) = (y, x % y)
return x
t=(int)(raw_input())
for i in range(t):
m, n = [int(x) for x in raw_input().split()]
result=pow(2,m+n)
result1=(pow(2,n)-1)*(result);
result-=1
print str(result)+str('/')+str(result1)
|
As the students are back in hostel after a long time, the gamers have decided to have a LAN gaming competition to find out who has utilized his time in gaming during vacations. They play "Counter ATOD". However, the scoring of this game is weird. There are N players and there are M rounds. Initially, each player has 0 points. The player gets the points only if he has won the round. Points can be negative too(weird).
The winner of the whole contest is the one who has maximum points after any round. However, it isn't necessary at all that the winner will have maximum points at the end of the game. As the scoring is pretty weird, they asks for your help.
Input Format :
First line of input will consist of N and M denoting the number of players and rounds respectively.
Next M lines will contain the name of the player who won the round and the points P he earned after that round.
First round will always have positive points.
Output Format:
The only line of output will contain the name of the winner who got maximum points in the contest at any point of the game.
In case of draw, the winner will be the player who got maximum points earlier.
Constraints :
1 ≤ N ≤ 100
1 ≤ M ≤ 5000
1 ≤ Length of name ≤ 15
-10^6 ≤ P ≤ 10^6
Problem Setter : Swastik Mundra
SAMPLE INPUT
3 5
Murliwala 5
Mithaiwala 4
Mithaiwala 4
Mithaiwala -2
Mirchiwala 8
SAMPLE OUTPUT
Mithaiwala
Explanation
After round 1, Murliwala wins the round and gains 5 points but as Mirchiwala and Mithaiwala has not won the round, they will not gain any point.
After round 2, Mithaiwala wins the round and gains 4 points. However Murliwala has still 5 points and Mirchiwala has 0 points.
After round 3, Mithaiwala wins the round and gains 4 points. His total is 8 points now and is maximum. However Murliwala has still 5 points and Mirchiwala has 0 points.
After round 4, Mithaiwala wins again and gains -2 points which brings his total to 6 points.
After round 5, Mirchiwala wins and gains 8 points.
Maximum points throughout the game was 8
but as Murliwala earned 8 points first he is the winner.
However, the total of Mithaiwala at the end was 6.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
print 'Hello World!'
'''
n,m=raw_input().split()
n=int(n)
m=int(m)
x=[]
y=[]
M=0
for i in range(m):
name,pt=raw_input().split()
pt=int(pt)
if name not in x:
#print(name,pt)
x.append(name)
ind=x.index(name)
else:
ind=x.index(name)
if ind<len(y):
y[ind]=y[ind]+pt
else:
y.append(pt)
if max(y)>M:
M=max(y)
W=name
print(W)
|
You will be given a contest schedule for D days. For each d=1,2,\ldots,D, calculate the satisfaction at the end of day d.
Input
Input is given from Standard Input in the form of the input of Problem A followed by the output of Problem A.
D
c_1 c_2 \cdots c_{26}
s_{1,1} s_{1,2} \cdots s_{1,26}
\vdots
s_{D,1} s_{D,2} \cdots s_{D,26}
t_1
t_2
\vdots
t_D
* The constraints and generation methods for the input part are the same as those for Problem A.
* For each d, t_d is an integer satisfying 1\leq t_d \leq 26, and your program is expected to work correctly for any value that meets the constraints.
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Example
Input
5
86 90 69 51 2 96 71 47 88 34 45 46 89 34 31 38 97 84 41 80 14 4 50 83 7 82
19771 12979 18912 10432 10544 12928 13403 3047 10527 9740 8100 92 2856 14730 1396 15905 6534 4650 11469 3628 8433 2994 10899 16396 18355 11424
6674 17707 13855 16407 12232 2886 11908 1705 5000 1537 10440 10711 4917 10770 17272 15364 19277 18094 3929 3705 7169 6159 18683 15410 9092 4570
6878 4239 19925 1799 375 9563 3445 5658 19857 11401 6997 6498 19933 3848 2426 2146 19745 16880 17773 18359 3921 14172 16730 11157 5439 256
8633 15862 15303 10749 18499 7792 10317 5901 9395 11433 3514 3959 5202 19850 19469 9790 5653 784 18500 10552 17975 16615 7852 197 8471 7452
19855 17918 7990 10572 4333 438 9140 9104 12622 4985 12319 4028 19922 12132 16259 17476 2976 547 19195 19830 16285 4806 4471 9457 2864 2192
1
17
13
14
13
Output
18398
35037
51140
65837
79325
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
// const int C = 26;
int D;
cin >> D;
vector<int> C(26); // 0 to 25
rep(i, 26) {
cin >> C.at(i);
}
vector<vector<int>> S(D, vector<int>(26)); // 0 to 364, 0 to 25
rep(i, D) {
rep(j, 26) {
cin >> S.at(i).at(j);
}
}
int ans = 0;
vector<int> L(26, 0); // 0 to 25
for (int d = 1; d <= D; d++) {
// 1 to 365
int t; // 1 to 26
cin >> t;
L.at(t - 1) = d;
ans += S.at(d - 1).at(t - 1);
rep(i, 26) {
ans -= C.at(i) * (d - L.at(i));
}
cout << ans << endl;
}
}
|
There are N stores called Store 1, Store 2, \cdots, Store N. Takahashi, who is at his house at time 0, is planning to visit some of these stores.
It takes Takahashi one unit of time to travel from his house to one of the stores, or between any two stores.
If Takahashi reaches Store i at time t, he can do shopping there after standing in a queue for a_i \times t + b_i units of time. (We assume that it takes no time other than waiting.)
All the stores close at time T + 0.5. If Takahashi is standing in a queue for some store then, he cannot do shopping there.
Takahashi does not do shopping more than once in the same store.
Find the maximum number of times he can do shopping before time T + 0.5.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2 \times 10^5
* 0 \leq a_i \leq 10^9
* 0 \leq b_i \leq 10^9
* 0 \leq T \leq 10^9
Input
Input is given from Standard Input in the following format:
N T
a_1 b_1
a_2 b_2
\vdots
a_N b_N
Output
Print the answer.
Examples
Input
3 7
2 0
3 2
0 3
Output
2
Input
1 3
0 3
Output
0
Input
5 21600
2 14
3 22
1 3
1 10
1 9
Output
5
Input
7 57
0 25
3 10
2 4
5 15
3 22
2 14
1 15
Output
3
|
#include<bits/stdc++.h>
#define sz(x) ((int)x.size())
#define pb push_back
#define ii pair<int,int>
#define ppb pop_back
#define orta ((bas+son)>>1)
#define st first
#define nd second
#define ll long long
#define N 200005
#define inf 1000000005
#define MOD 1000000007
#define LOG 29
#define EPS 0.000000001
#define M 305
using namespace std;
struct shop {
int a,b;
} s[N];
int n,t;
int dp[34][N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);cout.tie(0);
cin>>n>>t;
for(int i=1;i<=n;i++) {
cin>>s[i].a>>s[i].b;
}
sort(s+1,s+1+n,[](shop i,shop j) {
return (ll)(j.a)*(i.b+1)<(ll)(i.a)*(j.b+1);
});
int b=n;
for(int i=n;i>=1;i--) {
if(s[i].a!=0)
break ;
--b;
}
int magic=32;
for(int tot=1;tot<=magic;tot++) {
fill(dp[tot],dp[tot]+b+1,inf);
for(int i=1;i<=b;i++) {
dp[tot][i]=dp[tot][i-1];
ll prv=dp[tot-1][i-1];
ll nt=(prv+1)*(s[i].a+1)+s[i].b;
if(nt>t)
nt=inf;
dp[tot][i]=min((ll)dp[tot][i],nt);
}
}
sort(s+b+1,s+1+n,[](shop i,shop j) {
return i.b<j.b;
});
int res=0;
for(int tot=0;tot<=magic;tot++) {
int ct=dp[tot][b];
if(ct>t) continue ;
int ans=tot;
for(int i=b+1;i<=n;i++) {
if((ct+=s[i].b+1)>t)
break ;
ans++;
}
res=max(res,ans);
}
cout<<res;
}
|
The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)
We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.
Constraints
* 1 \leq A \leq 100
* 1 \leq B \leq 100
* A and B are integers.
Input
Input is given from Standard Input in the following format:
A B
Output
Print the total horizontal length of the uncovered parts of the window.
Examples
Input
12 4
Output
4
Input
20 15
Output
0
Input
20 30
Output
0
|
A, B = map(int, raw_input().split())
print(max(0, A - 2 * B))
|
Snuke is playing with red and blue balls, placing them on a two-dimensional plane.
First, he performed N operations to place red balls. In the i-th of these operations, he placed RC_i red balls at coordinates (RX_i,RY_i). Then, he performed another N operations to place blue balls. In the i-th of these operations, he placed BC_i blue balls at coordinates (BX_i,BY_i). The total number of red balls placed and the total number of blue balls placed are equal, that is, \sum_{i=1}^{N} RC_i = \sum_{i=1}^{N} BC_i. Let this value be S.
Snuke will now form S pairs of red and blue balls so that every ball belongs to exactly one pair. Let us define the score of a pair of a red ball at coordinates (rx, ry) and a blue ball at coordinates (bx, by) as |rx-bx| + |ry-by|.
Snuke wants to maximize the sum of the scores of the pairs. Help him by finding the maximum possible sum of the scores of the pairs.
Constraints
* 1 \leq N \leq 1000
* 0 \leq RX_i,RY_i,BX_i,BY_i \leq 10^9
* 1 \leq RC_i,BC_i \leq 10
* \sum_{i=1}^{N} RC_i = \sum_{i=1}^{N} BC_i
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
RX_1 RY_1 RC_1
RX_2 RY_2 RC_2
\vdots
RX_N RY_N RC_N
BX_1 BY_1 BC_1
BX_2 BY_2 BC_2
\vdots
BX_N BY_N BC_N
Output
Print the maximum possible sum of the scores of the pairs.
Examples
Input
2
0 0 1
3 2 1
2 2 1
5 0 1
Output
8
Input
3
0 0 1
2 2 1
0 0 2
1 1 1
1 1 1
3 3 2
Output
16
Input
10
582463373 690528069 8
621230322 318051944 4
356524296 974059503 6
372751381 111542460 9
392867214 581476334 6
606955458 513028121 5
882201596 791660614 9
250465517 91918758 3
618624774 406956634 6
426294747 736401096 5
974896051 888765942 5
726682138 336960821 3
715144179 82444709 6
599055841 501257806 6
390484433 962747856 4
912334580 219343832 8
570458984 648862300 6
638017635 572157978 10
435958984 585073520 7
445612658 234265014 6
Output
45152033546
|
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+7,inf=1e9+7; bool fl[N];
int n,s,t,cnt,tot,ch[4],f[N],pre[N],que[N<<2];
long long sum,dis[N];
struct edge{int u,v,t,q,s;}ed[N<<1];
inline int read(){
int num=0; char g=getchar(); while(g<48||57<g) g=getchar();
while(47<g&&g<58) num=(num<<1)+(num<<3)+g-48,g=getchar(); return num;
}
inline void add(int a,int b,int c,int d){
tot++,ed[tot].u=a,ed[tot].v=b,ed[tot].t=c,ed[tot].q=d,ed[tot].s=f[a],f[a]=tot;
}
inline void addedge(int a,int b,int c,int d){
add(a,b,c,d),add(b,a,0,-d);
}
inline void flows(){
for(int i=1;i<=cnt;i++) dis[i]=0;
int head=1,tail=1; que[head]=s; dis[s]=1e18;
while(head<=tail){
int x=que[head++]; fl[x]=0;
for(int i=f[x];i>0;i=ed[i].s){
if(!ed[i].t) continue;
int u=ed[i].v;
if(dis[u]<dis[x]+ed[i].q){
dis[u]=dis[x]+ed[i].q,pre[u]=i;
if(!fl[u]) fl[u]=1,que[++tail]=u;
}
}
}
int z=inf,u=t; if(!dis[u]) return; long long xs=0;
while(u!=s) z=min(z,ed[pre[u]].t),xs=xs+ed[pre[u]].q,u=ed[pre[u]].u; sum=sum+xs*z,u=t;
while(u!=s) ed[pre[u]].t-=z,ed[pre[u]^1].t+=z,u=ed[pre[u]].u;
}
int main(){
n=read(),s=++cnt,t=++cnt,ch[0]=++cnt,ch[1]=++cnt,ch[2]=++cnt,ch[3]=++cnt,tot=1;
for(int i=1;i<=n;i++){
int x=read(),y=read(),c=read(),q=++cnt;
addedge(s,q,c,0);
for(int z=0;z<4;z++){
int h=0; if(z&1) h=h+x; else h=h-x; if(z&2) h=h+y; else h=h-y;
addedge(q,ch[z],inf,h);
}
}
for(int i=1;i<=n;i++){
int x=read(),y=read(),c=read(),q=++cnt;
addedge(q,t,c,0);
for(int z=0;z<4;z++){
int h=0; if(z&1) h=h-x; else h=h+x; if(z&2) h=h-y; else h=h+y;
addedge(ch[z],q,inf,h);
}
}
dis[t]=1; while(dis[t]) flows(); cout<<sum<<endl;
return 0;
}
|
There are N stones, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), the height of Stone i is h_i.
There is a frog who is initially on Stone 1. He will repeat the following action some number of times to reach Stone N:
* If the frog is currently on Stone i, jump to Stone i + 1 or Stone i + 2. Here, a cost of |h_i - h_j| is incurred, where j is the stone to land on.
Find the minimum possible total cost incurred before the frog reaches Stone N.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq h_i \leq 10^4
Input
Input is given from Standard Input in the following format:
N
h_1 h_2 \ldots h_N
Output
Print the minimum possible total cost incurred.
Examples
Input
4
10 30 40 20
Output
30
Input
2
10 10
Output
0
Input
6
30 10 60 10 60 50
Output
40
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
vector<int> h(n),dp(n);
for(int i=0;i<n;i++) cin>>h[i];
dp[0]=0;
dp[1]=abs(h[1]-h[0]);
for(int i=2;i<n;i++){
dp[i]=min(dp[i-1]+abs(h[i]-h[i-1]),dp[i-2]+abs(h[i]-h[i-2]));
}
cout<<dp[n-1];
}
|
You are given a string S consisting of lowercase English letters. We will write down this string, starting a new line after every w letters. Print the string obtained by concatenating the letters at the beginnings of these lines from top to bottom.
Constraints
* 1 \leq w \leq |S| \leq 1000
* S consists of lowercase English letters.
* w is an integer.
Input
Input is given from Standard Input in the following format:
S
w
Output
Print the desired string in one line.
Examples
Input
abcdefgh
3
Output
adg
Input
lllll
1
Output
lllll
Input
souuundhound
2
Output
suudon
|
S = list(input())
w = int(input())
ans = S[::w]
for a in ans:
print(a, end="")
print()
|
A game is played on a strip consisting of N cells consecutively numbered from 1 to N.
Alice has her token on cell A. Borys has his token on a different cell B.
Players take turns, Alice moves first. The moving player must shift his or her token from its current cell X to the neighboring cell on the left, cell X-1, or on the right, cell X+1. Note that it's disallowed to move the token outside the strip or to the cell with the other player's token. In one turn, the token of the moving player must be shifted exactly once.
The player who can't make a move loses, and the other player wins.
Both players want to win. Who wins if they play optimally?
Constraints
* 2 \leq N \leq 100
* 1 \leq A < B \leq N
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
Print `Alice` if Alice wins, `Borys` if Borys wins, and `Draw` if nobody wins.
Examples
Input
5 2 4
Output
Alice
Input
2 1 2
Output
Borys
Input
58 23 42
Output
Borys
|
#include<iostream>
using namespace std;
int main(){
int n,a,b;
cin>>n>>a>>b;
cout<<(((a-b)%2==0)?"Alice":"Borys")<<endl;
}
|
You are participating in a quiz with N + M questions and Yes/No answers.
It's known in advance that there are N questions with answer Yes and M questions with answer No, but the questions are given to you in random order.
You have no idea about correct answers to any of the questions. You answer questions one by one, and for each question you answer, you get to know the correct answer immediately after answering.
Suppose you follow a strategy maximizing the expected number of correct answers you give.
Let this expected number be P/Q, an irreducible fraction. Let M = 998244353. It can be proven that a unique integer R between 0 and M - 1 exists such that P = Q \times R modulo M, and it is equal to P \times Q^{-1} modulo M, where Q^{-1} is the modular inverse of Q. Find R.
Constraints
* 1 \leq N, M \leq 500,000
* Both N and M are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
Let P/Q be the expected number of correct answers you give if you follow an optimal strategy, represented as an irreducible fraction. Print P \times Q^{-1} modulo 998244353.
Examples
Input
1 1
Output
499122178
Input
2 2
Output
831870297
Input
3 4
Output
770074220
Input
10 10
Output
208827570
Input
42 23
Output
362936761
|
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cassert>
#define MOD 998244353
#define ll long long
using namespace std;
inline int read(){
int re=0,flag=1;char ch=getchar();
while(!isdigit(ch)){
if(ch=='-') flag=-1;
ch=getchar();
}
while(isdigit(ch)) re=(re<<1)+(re<<3)+ch-'0',ch=getchar();
return re*flag;
}
ll n,m,f[1000010],finv[1000010];
ll qpow(ll a,ll b){
ll re=1;
while(b){
if(b&1) re=re*a%MOD;
a=a*a%MOD;b>>=1;
}
return re;
}
void init(){
ll i,len=n+m;
f[0]=f[1]=finv[0]=finv[1]=1;
for(i=2;i<=len;i++) f[i]=f[i-1]*i%MOD;
finv[len]=qpow(f[len],MOD-2);
for(i=len;i>2;i--) finv[i-1]=finv[i]*i%MOD;
}
ll C(ll y,ll x){
// cout<<"C "<<x<<' '<<y<<' '<<f[x]<<' '<<finv[y]<<' '<<finv[x-y]<<'\n';
return f[x]*finv[y]%MOD*finv[x-y]%MOD;
}
int main(){
n=read();m=read();int i;ll ans=0;
if(n<m) swap(n,m);
init();
for(i=1;i<=m;i++) (ans+=C(i,2*i)*C(n-i,n+m-2*i)%MOD)%=MOD;
ans=ans*qpow(2*C(n,n+m)%MOD,MOD-2)%MOD;
// cout<<ans<<'\n';
ans=(ans+n+MOD)%MOD;
cout<<ans;
}
|
There is a kangaroo at coordinate 0 on an infinite number line that runs from left to right, at time 0. During the period between time i-1 and time i, the kangaroo can either stay at his position, or perform a jump of length exactly i to the left or to the right. That is, if his coordinate at time i-1 is x, he can be at coordinate x-i, x or x+i at time i. The kangaroo's nest is at coordinate X, and he wants to travel to coordinate X as fast as possible. Find the earliest possible time to reach coordinate X.
Constraints
* X is an integer.
* 1≤X≤10^9
Input
The input is given from Standard Input in the following format:
X
Output
Print the earliest possible time for the kangaroo to reach coordinate X.
Examples
Input
6
Output
3
Input
2
Output
2
Input
11
Output
5
|
#include<iostream>
using namespace std;
int main() {
int x; cin >> x;
int now = 0, time = 0;
for (int i = 1; now < x; i++) {
now += i, time = i;
}
cout << time << endl;
return 0;
}
|
Snuke is interested in strings that satisfy the following conditions:
* The length of the string is at least N.
* The first N characters equal to the string s.
* The last N characters equal to the string t.
Find the length of the shortest string that satisfies the conditions.
Constraints
* 1≤N≤100
* The lengths of s and t are both N.
* s and t consist of lowercase English letters.
Input
The input is given from Standard Input in the following format:
N
s
t
Output
Print the length of the shortest string that satisfies the conditions.
Examples
Input
3
abc
cde
Output
5
Input
1
a
z
Output
2
Input
4
expr
expr
Output
4
|
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
Scan sc= new Scan();
int n =sc.scanInt();
String s = sc.scanString();
String t = sc.scanString();
String middle = "";
int i = 0;
for(; i < n; ++i){
String first = s.substring(i,n);
String second = t.substring(0,n-i);
if(first.equals(second)){
System.out.println(n+i);
return;
}
}
System.out.println(2*n);
}
}
class Scan
{
private byte[] buf=new byte[1024];
private int index;
private InputStream in;
private int total;
public Scan()
{
in=System.in;
}
public int scan()throws IOException
{
if(total<0)
throw new InputMismatchException();
if(index>=total)
{
index=0;
total=in.read(buf);
if(total<=0)
return -1;
}
return buf[index++];
}
public int scanInt()throws IOException
{
int integer=0;
int n=scan();
while(isWhiteSpace(n))
n=scan();
int neg=1;
if(n=='-')
{
neg=-1;
n=scan();
}
while(!isWhiteSpace(n))
{
if(n>='0'&&n<='9')
{
integer*=10;
integer+=n-'0';
n=scan();
}
else throw new InputMismatchException();
}
return neg*integer;
}
public long scanLong() throws IOException {
long integer=0;
int n=scan();
while(isWhiteSpace(n))
n=scan();
int neg=1;
if(n=='-')
{
neg=-1;
n=scan();
}
while(!isWhiteSpace(n))
{
if(n>='0'&&n<='9')
{
integer*=10;
integer+=n-'0';
n=scan();
}
else throw new InputMismatchException();
}
return neg*integer;
}
public double scanDouble()throws IOException
{
double doub=0;
int n=scan();
while(isWhiteSpace(n))
n=scan();
int neg=1;
if(n=='-')
{
neg=-1;
n=scan();
}
while(!isWhiteSpace(n)&&n!='.')
{
if(n>='0'&&n<='9')
{
doub*=10;
doub+=n-'0';
n=scan();
}
else throw new InputMismatchException();
}
if(n=='.')
{
n=scan();
double temp=1;
while(!isWhiteSpace(n))
{
if(n>='0'&&n<='9')
{
temp/=10;
doub+=(n-'0')*temp;
n=scan();
}
else throw new InputMismatchException();
}
}
return doub*neg;
}
public String scanString()throws IOException
{
StringBuilder sb=new StringBuilder();
int n=scan();
while(isWhiteSpace(n))
n=scan();
while(!isWhiteSpace(n))
{
sb.append((char)n);
n=scan();
}
return sb.toString();
}
private boolean isWhiteSpace(int n)
{
if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
return true;
return false;
}
}
|
Using the given four integers from 1 to 9, we create an expression that gives an answer of 10. When you enter four integers a, b, c, d, write a program that outputs an expression that gives an answer of 10 according to the following conditions. Also, if there are multiple answers, only the first answer found will be output. If there is no answer, output 0.
* Use only addition (+), subtraction (-), and multiplication (*) as operators. Do not use division (/). You can use three operators.
* You must use all four numbers.
* You can freely change the order of the four numbers.
* You can use parentheses. You can use up to 3 sets (6) of parentheses.
Input
Given multiple datasets. The format of each dataset is as follows:
a b c d
Input ends with four 0s. The number of datasets does not exceed 40.
Output
For each dataset, combine the given four integers with the above arithmetic symbols and parentheses to output an expression or 0 with a value of 10 on one line. The expression string must not exceed 1024 characters.
Example
Input
8 7 9 9
4 4 4 4
5 5 7 5
0 0 0 0
Output
((9 * (9 - 7)) - 8)
0
((7 * 5) - (5 * 5))
|
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
bool calc(vector<char> op){
int st[4],sp=0;
rep(i,op.size()){
if('1'<=op[i]&&op[i]<='9'){
st[sp++] = op[i]-'0';
}
else{
if(sp<2)return false;
int a,b;
b=st[--sp];
a=st[--sp];
if(op[i]=='+')st[sp++] = a+b;
if(op[i]=='-')st[sp++] = a-b;
if(op[i]=='*')st[sp++] = a*b;
}
}
return sp==1 && st[0]==10;
}
string trans(vector<char> op){
string st[4];
int sp=0;
rep(i,op.size()){
if('1'<=op[i]&&op[i]<='9'){
st[sp++] = op[i];
}
else{
string a,b;
b= '('+st[--sp]+')';
a= '('+st[--sp]+')';
st[sp++] = a+op[i]+b;
}
}
return st[0];
}
int main(){
vector<char> input(4),a;
char operation[]="+-*";
while(1){
string ans="0";
rep(i,4)cin>>input[i];
if(count(input.begin(),input.end(),'0')==4)break;
for(int i=0;i<3;i++){
for(int j=i;j<3;j++){
for(int k=j;k<3;k++){
a=input;
a.push_back(operation[i]);
a.push_back(operation[j]);
a.push_back(operation[k]);
sort(a.begin(),a.end());
do{
if(calc(a))ans=trans(a);
}while(next_permutation(a.begin(),a.end()));
}
}
}
cout<<ans<<endl;
}
return 0;
}
|
Aizu Gakuen High School holds a school festival every year. The most popular of these is the haunted house. The most popular reason is that 9 classes do haunted houses instead of 1 or 2 classes. Each one has its own unique haunted house. Therefore, many visitors come from the neighborhood these days.
Therefore, the school festival executive committee decided to unify the admission fee for the haunted house in the school as shown in the table below, and based on this, total the total number of visitors and income for each class.
Admission fee list (admission fee per visitor)
Morning Afternoon
200 yen 300 yen
Enter the number of visitors in the morning and afternoon for each class, and create a program that creates a list of the total number of visitors and income for each class.
Input
The input is given in the following format:
name1 a1 b1
name2 a2 b2
::
name9 a9 b9
The input consists of 9 lines, the class name of the i-th class on the i-line namei (a half-width character string of 1 to 15 characters including numbers and alphabets), the number of visitors in the morning ai (0 ≤ ai ≤ 400) , Afternoon attendance bi (0 ≤ bi ≤ 400) is given.
Output
On the i-line, output the class name of the i-class, the total number of visitors, and the fee income on one line separated by blanks.
Example
Input
1a 132 243
1c 324 183
1f 93 199
2b 372 163
2c 229 293
2e 391 206
3a 118 168
3b 263 293
3d 281 102
Output
1a 375 99300
1c 507 119700
1f 292 78300
2b 535 123300
2c 522 133700
2e 597 140000
3a 286 74000
3b 556 140500
3d 383 86800
|
#include <iostream>
#include <string>
using namespace std;
int main()
{
int i,j,k;
string n;
for(i=0;i<9;i++){
cin >> n >> j >> k;
cout << n << " " << j+k << " " << j*200+k*300 << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.