input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
Time Limit: 8 sec / Memory Limit: 64 MB
Example
Input
2
4 2
4 0.4000000
3 0.5000000
4 1
5 0.3333333
5 3
5 0.7777777
4 0.1111111
2 0.0001111
Output
YES
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,k,n) for(int i = (k); i < (n); i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) a.begin(), a.end()
#define MS(m,v) memset(m,v,sizeof(m))
#define D10 fixed<<setprecision(10)
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
const int MOD = 1000000007;
const int INF = MOD + 1;
const ld EPS = 0.0000001;
template<class T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template<class T> T &chmax(T &a, const T &b) { return a = max(a, b); }
/*--------------------template--------------------*/
int main()
{
int t;
cin >> t;
ld mx = 0;
REP(i, t)
{
int n, m;
cin >> n >> m;
ld sum = 0;
ld ex = 0;
REP(j, m)
{
int v; ld r;
cin >> v >> r;
ex += v*r;
sum += r;
}
chmax(mx, ex*(1 / sum));
}
int p, q;
cin >> p >> q;
ld sum = 0;
ld ex = 0;
REP(j, q)
{
int v; ld r;
cin >> v >> r;
ex += v*r;
sum += r;
}
if (mx - ex*(1/sum) > EPS) puts("YES");
else puts("NO");
return 0;
}
|
Mr. B loves Brainf * ck and submits all the assignments given at school using Brainf * ck. Recently, I was brainwashed by Mr. B, and the teacher limited the language to solve the problem to Brainf * ck.
At this rate, everyone will lose credit. You decide to help rescue everyone's units by creating a program that will generate a Brainf * ck program.
Of course, the program that generates the Brainf * ck program does not need to be written in Brainf * ck.
problem
Generate a Brainf * ck program that outputs the specified string \\ (s \\).
Brainf * ck language specification
Describe the language specifications of Brainf * ck used by judges.
Brainf * ck programs are written as strings. The program string must support square brackets ([and]), but there are no other restrictions.
When the Brainf * ck program is executed, it has a pointer to a byte array and its elements. The byte array has an infinite size and can hold 8-bit non-negative integer information. This is expressed in C language as follows.
unsigned char memory [100000]; // Byte array (actually reserves a larger area)
unsigned char * ptr = memory; // Pointer pointing to an element of the byte array
In Brainf * ck, one instruction is represented by one character, and there are the following seven types of instructions.
Character | Meaning | Notation in C language
--- | --- | ---
`+` | Increases the value of the element in the byte array indicated by the pointer by 1. When the value is 255, it becomes 0. | `(* ptr) ++;`
`-` | Decrease the value of the element in the byte array indicated by the pointer by 1. When the value is 0, it becomes 255. | `(* ptr)-;`
`>` | Shifts the position of the element of the byte array indicated by the pointer by exactly 1. | `ptr ++;`
`<` | Shifts the position of the element of the byte array indicated by the pointer by one negative. | `ptr-;`
`[` | If the value of the byte array element pointed to by the pointer is 0, jump to the corresponding `]`. Otherwise, proceed to the next instruction. | `while (* ptr) {`
`]` | If the value of the byte array element pointed to by the pointer is 0, jump to the corresponding `[`. Otherwise, proceed to the next instruction. | `} do while (* ptr);`
`.` | The value of the element of the byte array indicated by the pointer is regarded as ASCII code, and the character is output. | `putchar (* ptr);`
Instructions are executed in order from the beginning, and characters that are not the characters that represent the instruction are ignored as comments.
The above Brainf * ck specifications are almost the same as the commonly used Brainf * ck, so you can refer to http://ja.wikipedia.org/wiki/Brainfuck. However, please note that Brainf * ck used for judges cannot use single-character input commands.
input
A string of up to 1000 characters \\ (s \\) is given on a line.
output
Output the Brainf * ck code within 20000 characters. Any program whose execution result matches \\ (s \\) is accepted.
Constraint
* \\ (1 \ leq | s | \ leq 1000 \\)
* \\ (s \\) is an ASCII string
* \\ (s \\) contains only ASCII code 33-126 characters (symbols, letters, numbers only, no spaces or control characters)
* The length of the output program can be up to \\ (20000 \\) characters including blanks, line breaks, and comments.
* The instruction stops after being executed \\ (10 ^ 7 \\) times
* Brainf * ck programs must not output newlines at the end
Input / output example
Input 1
ABC
Output 1
++++++++ [> ++++++++ <-]> +. +. +.
Input 2
Hello World !!
Output 2
+++++++++ [> ++++++++ <-]>. <+++++ [> +++++ <-]> ++++. ++++ +++ .. +++. [> +> + <<-] ++++ [> ------ <-]>.>. +++ .--
---- .-- -------- [-] ++++++ [> +++++ <-]> +++ ..
The input does not contain blanks.
Input 3
! "# $% &'() * +,-./ 0123456789 :; <=>? @ABCDEFGHIJKLMNOPQRSTUVWXYZ [\] ^ _`abcdefghijklmnopqrstuvwxyz {|} ~
Output 3
+++++++++++++++++++++++++++++++++. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +
+. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +
. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +.
This case is a sequence of 33-126 ASCII codes.
Example
Input
ABC
Output
++++++++[>++++++++<-]>+.+.+.
|
#include<iostream>
using namespace std;
int main(){string s,u="[<++++++++++>-]>",c=">+++++[<++++++>-]>+++++[<++++++++>-]>+++++"+u+"++++++"+u+"+++++++"+u+"++++++++"+u+"+++++++++"+u+"++++++++++"+u+"+++++++++++"+u+"++++++++++++"+u+"<<<<<<<<<<<";
int p=0,i,j,a,b,d;for(cin>>s,i=0;i<s.length();++i){a=s[i]/10-3,b=a-p,p=a,d=s[i]-a*10-30;for(j=b>0?b:-b;j--;)c+=(b>=0?62:60);for(j=d;j--;)c+=43;c+=46;for(j=d;j--;)c+=45;}cout<<c<<endl;}
|
Example
Input
3 2
1 2 1
2 3 2
1 10 100
Output
320
|
#include<bits/stdc++.h>
using namespace std;
#define MAX 2005
typedef long long ll;
struct edge{ll to,cost;};
vector<ll> ans;
vector<edge> G[MAX];
ll A[MAX];
int n,m;
ll a,b,c;
ll dfs(int pos,int prev,int root,ll cost){
vector<ll> res;
for(int i=0;i<(int)G[pos].size();i++){
edge e=G[pos][i];
if(e.to==prev)continue;
res.push_back(dfs(e.to,pos,root,cost)+e.cost*A[root]);
}
sort(res.begin(),res.end());
reverse(res.begin(),res.end());
for(int i=1;i<(int)res.size();i++)ans.push_back(res[i]);
return (res.empty()?0LL:res[0]);
}
int main(){
cin>>n>>m;
for(int i=0;i<n-1;i++){
cin>>a>>b>>c;
a--,b--;
G[a].push_back((edge){b,c});
G[b].push_back((edge){a,c});
}
for(int i=0;i<n;i++)cin>>A[i];
for(int i=0;i<n;i++)ans.push_back(dfs(i,-1,i,0));
sort(ans.begin(),ans.end());
reverse(ans.begin(),ans.end());
for(int i=1;i<(int)ans.size();i++)ans[i]+=ans[i-1];
cout<< ans[ min(m-1,(int)ans.size()-1) ] <<endl;
return 0;
}
|
Convex polygon pillar industrial city
The Industrial Convex Pillar City (ICPC) is a city of buildings in the shape of several convex polygonal columns. You are about to walk through this city from your current location S to your destination T. The sun is strong today, so I want to go to my destination without passing through the sun as much as possible. If the building is on a straight line connecting the point where you are standing and the sun, you are behind the building and will not be exposed to the sun. Also, since all the outer circumferences of the buildings in this city have eaves, while walking along the outer circumference of the buildings, even if you walk along the edge of the sun, you will not receive the sunlight. You are free to walk around the city anywhere except inside the building.
Create a program that outputs the walking distance of Hinata when walking from the current location to the destination so as not to receive the sun.
<image>
Figure E1: For the first input
<image>
Figure E2: For the second input
<image>
Figure E3: For the third input
Input
The input consists of multiple datasets. The maximum number of data sets does not exceed 30. Each dataset is represented in the following format.
> N
> NV1 H1 X1,1 Y1,1 X1,2 Y1,2 ... X1, NV1 Y1, NV1
> ...
> NVN HN XN, 1 YN, 1 XN, 2 YN, 2 ... XN, NVN YN, NVN
> θ φ
> Sx Sy Tx Ty
>
N in the first line represents the number of buildings. The following N lines specify the shape of each building. NVi represents the number of vertices of the polygon when the i-th building is viewed from above, and Hi represents the height of the i-th building. Xi, j and Yi, j represent the x-coordinate and y-coordinate of the j-th vertex of the polygon when the i-th building is viewed from above. The vertices are given in counterclockwise order. All buildings are convex polygons when viewed from above, and there are no other buildings inside the building, and the vertices and sides do not overlap with other polygons. The following lines are given θ and φ, which represent the direction of the sun, θ represents the direction of the sun as a counterclockwise angle from the positive direction of x, and φ is the elevation angle of the sun from the horizon, that is, looking up at the sun. It represents the angle between the direction of the line of sight and the ground surface. However, the sun is at infinity and does not change its position during movement. The following lines are given the coordinates of the current location and destination, (Sx, Sy) and (Tx, Ty).
> All the numerical values given by the input are integers and satisfy the following conditions.
> 1 ≤ N ≤ 100
> 3 ≤ NVi ≤ 12
> 1 ≤ Hi ≤ 1,000
> 0 ≤ θ <360
> 0 <φ <90
All coordinates are -1,000 or more and 1,000 or less. The current location and the destination are different, and neither exists inside or outside the building.
> The end of the input is represented by a single zero line.
> ### Output
For each dataset, output the shortest walking distance in Hinata on one line. The output must not have an absolute error greater than 0.001.
> ### Sample Input
2
4 1 0 0 1 0 1 1 0 1
4 2 2 2 3 2 3 3 2 3
60 45
-1 -1 4 4
Four
4 1 0 0 3 1 1 2 0 1
3 2 10 7 8 2 12 4
6 8 7 12 8 13 9 15 10 19 11 24 10 25
5 4 16 2 16 4 12 8 14 2 15 0
167 38
3 3 15 21
12
4 3 -8 -3 -9 -3 -9 -5 -8 -6
4 5 -4 -5 -7 -5 -7 -6 -5 -6
4 2 -4 1 -5 1 -5 -4 -4 -4 -4
4 1 -1 1 -2 1 -2 -4 -1 -3
4 2 2 3 -1 3 -2 2 3 2
4 1 3 1 2 1 2 -3 3 -4
4 7 1 0 0 0 0 -1 1 -1
4 4 9 5 7 5 7 4 10 4
4 3 6 5 5 4 5 0 6 0
4 5 8 -1 5 -1 6 -2 8 -2
4 1 10 0 9 0 9 -2 10 -1
4 6 10 2 8 2 8 1 10 1
131 78
-10 10 10 -10
0
Output for Sample Input
1.93185
7.87174
20.86840
Example
Input
2
4 1 0 0 1 0 1 1 0 1
4 2 2 2 3 2 3 3 2 3
60 45
-1 -1 4 4
4
4 1 0 0 3 1 1 2 0 1
3 2 10 7 8 2 12 4
6 8 7 12 8 13 9 15 10 19 11 24 10 25
5 4 16 2 16 4 12 8 14 2 15 0
167 38
3 3 15 21
12
4 3 -8 -3 -9 -3 -9 -5 -8 -6
4 5 -4 -5 -7 -5 -7 -6 -5 -6
4 2 -4 1 -5 1 -5 -4 -4 -4
4 1 -1 1 -2 1 -2 -4 -1 -3
4 2 2 3 -1 3 -2 2 3 2
4 1 3 1 2 1 2 -3 3 -4
4 7 1 0 0 0 0 -1 1 -1
4 4 9 5 7 5 7 4 10 4
4 3 6 5 5 4 5 0 6 0
4 5 8 -1 5 -1 6 -2 8 -2
4 1 10 0 9 0 9 -2 10 -1
4 6 10 2 8 2 8 1 10 1
131 78
-10 10 10 -10
0
Output
1.93185
7.87174
20.86840
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<pint> vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=n-1;i>=(0);i--)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define all(v) (v).begin(),(v).end()
#define eall(v) unique(all(v), v.end())
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll INFF = 1e18;
const double EPS = 1e-10;
const double PI = 3.141592653589793;
template<class T> bool eq(T a, T b){ return abs(a - b) < EPS; }
class Point { // ???
public:
double x, y;
Point(double x = 0, double y = 0):x(x), y(y){}
Point operator + (Point p) const { return Point(x + p.x, y + p.y); }
Point operator - (Point p) const { return Point(x - p.x, y - p.y); }
Point operator * (double a) const { return Point(a * x, a * y); }
Point operator / (double a) const { return Point(x / a, y / a); }
double abs() const { return sqrt(norm()); }
double norm() const { return x * x + y * y; }
// bool operator < (const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator < (const Point &p) const { // ??????????¨±???????????????
return x + EPS < p.x || (eq<double>(x, p.x) && y + EPS < p.y);
}
bool operator == (const Point &p) const { return (eq<double>(x, p.x) && eq<double>(y, p.y)); }
};
using Vector = Point;
using Polygon = vector<Point>; // ????§???¢
double dot(const Vector& a, const Vector& b) { return a.x * b.x + a.y * b.y; } // ????????????a??¨b?????????
double cross(const Vector& a, const Vector& b) { return a.x * b.y - a.y * b.x; } // ????????????a??¨b?????????
double length2(const Point& a) { return a.norm(); } // ??????????????????2???
double length(const Point& a) { return a.abs(); } // ???????????????
Point rotationalTransfer(Point c, double r, double deg) { // c???????????¨????????????r????????¨??????deg??????????????§?¨?
double rad = PI * deg / 180.0; return c + Point(cos(rad), sin(rad)) * r;
}
// (x, y, z) ???????????????(xy??§?¨???§????§???????theta???, xy?????¢??????z?????????????§???????phi????????????)??????????????????????????±???xy??§?¨?
Point Shadow(double x, double y, double z, double theta, double phi) {
theta = PI * theta / 180.0, phi = PI * phi / 180.0;
return Point(x - z / tan(phi) * cos(theta), y - z / tan(phi) * sin(theta));
}
enum ccw_t {
COUNTER_CLOCKWISE = 1, // p0->p1 ???????¨???????????????????p2
CLOCKWISE = -1, // p0->p1 ????¨???????????????????p2
ONLINE_BACK = 2, // p2->p0->p1 ????????§??´????????§p2
ONLINE_FRONT = -2, // p0->p1->p2 ????????§??´??????p2
ON_SEGMENT = 0, // p0->p2->p1 ????????§??????p0p1??????p2
};
ccw_t ccw(Point p0, Point p1, Point p2) {
Vector a = p1 - p0, b = p2 - p0;
if ( cross(a, b) > EPS ) return COUNTER_CLOCKWISE;
if ( cross(a, b) < -EPS ) return CLOCKWISE;
if ( dot(a, b) < -EPS ) return ONLINE_BACK;
if ( a.norm() < b.norm() ) return ONLINE_FRONT;
return ON_SEGMENT;
}
class Segment { //??????
public:
Point p1, p2;
Segment(){}
Segment(Point p1, Point p2):p1(p1), p2(p2){}
};
using Line = Segment;
// *** ????§???¢ ***
// IN := 2, ON := 1, OUT := 0
vector<Segment> getPolygonSegument(const Polygon& p) { //????§???¢????????????????§???¢??????????±???????
vector<Segment> ret;
rep(i, p.size() - 1) ret.push_back(Segment(p[i], p[i + 1]));
ret.push_back(Segment(p[p.size() - 1], p[0]));
return ret;
}
int contains(const Polygon& g, const Point& p){ // ????§???¢g????????????p????????????????????????
int n = g.size(); bool x = false;
for (int i = 0; i < n; ++i) {
Point 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;
}
return (x ? 2 : 0);
}
Polygon andrewScan(Polygon s) { // ??????(??????????????????????????????)
Polygon u, l;
if (s.size() < 3) return s;
sort(s.begin(), s.end()); // x, y???????????????????????????
// x????°???????????????????2??? u ?????????
u.push_back(s[0]), u.push_back(s[1]);
// x ?????§??????????????????2???1?????????
l.push_back(s[s.size() - 1]), l.push_back(s[s.size() - 2]);
// ??????????????¨?????????
for (int i = 2; i < s.size(); i++) {
for (int n = u.size(); n >= 2 && ccw(u[n - 2], u[n - 1], s[i]) != CLOCKWISE; n--){
u.pop_back();
}
u.push_back(s[i]);
}
// ??????????????¨?????????
for (int i = s.size() - 3; i >= 0; i--) {
for (int n = l.size(); n >= 2 && ccw(l[n - 2], l[n - 1], s[i]) != CLOCKWISE; n--){
l.pop_back();
}
l.push_back(s[i]);
}
// ????¨????????????????????????????????????????????????????
reverse(l.begin(), l.end());
for (int i = u.size() - 2; i >= 1; i--) l.push_back(u[i]);
return l;
}
// *** ????????????????????? ***
bool intersect(const Point& p1, const Point& p2, const Point& p3, const Point& p4) {
return ( ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0 );
}
bool intersect(const Segment& s1, const Segment& s2) { // ?????????????????????true
return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
//*** ??????????????? ***
Point getCrossPoint(Segment s1, Segment s2) { // ???????????????????????¨??????????????????????????????????????¨
Vector base = s2.p2 - s2.p1;
double d1 = abs(cross(base, s1.p1 - s2.p1)), d2 = abs(cross(base, s1.p2 - s2.p1));
double t = d1 / (d1 + d2);
return s1.p1 + (s1.p2 - s1.p1) * t;
}
// *** ?????¢ ***
double getDistance(Point& a, Point& b) { // ???a??¨???b????????¢
return length(a - b);
}
double getDistanceLP(Line& l, Point& p) { // ??´???s??¨???p????????¢
return length(cross(l.p2 - l.p1, p - l.p1) / length(l.p2 - l.p1));
}
double getDistanceSP(Segment s, Point p) { // ??????s??¨???p????????¢
if( dot(s.p2 - s.p1, p - s.p1) < EPS ) return length(p - s.p1);
if( dot(s.p1 - s.p2, p - s.p2) < EPS ) return length(p - s.p2);
return getDistanceLP(s, p);
}
double getDistanceSS(const Segment& s1, const Segment& s2) { // ??????s1??¨??????s2?????????
if( intersect(s1, s2) ) return 0.0; //????????£???????????¨???
return min(min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)),
min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)));
}
double getDistancePolP(const Polygon& pol, const Point& p) { // ????§???¢pol??¨???p????????¢
if(contains(pol, p) != 0) return 0.0; // ??????????§???¢????????¨?????????????????????
double ret = 1e9;
for(Segment& u : getPolygonSegument(pol)) ret = min(ret, getDistanceSP(u, p));
return ret;
}
double getDistancePolPol(const Polygon& p1, const Polygon& p2) { // ????§???¢p1??¨p2????????¢
for(const Point& p : p1) if(contains(p2, p) != 0) return 0.0; // p1?????????????§???¢p2???????????????????????????
for(const Point& p : p2) if(contains(p1, p) != 0) return 0.0; // p2?????????????§???¢p1???????????????????????????
double ret = 1e9;
for(const Segment& u : getPolygonSegument(p1))for(const Segment& v : getPolygonSegument(p2)) {
ret = min(ret, getDistanceSS(u, v));
}
return ret;
}
class Rectangle { // ????????¢
public:
// 3 2
// 0 1 (???????¨??????????????????¢??????????????????????????¨)
vector<Point> p; // ?????????????????????????????¨
Rectangle(vector<Point>&p):p(p) {
rep(i, 3) reps(j, i + 1, 4) { //????????????????????????????????§???????????????????
int cnt = 0;
rep(k, 4) if(k != i && k != j) {
cnt += ccw(p[i], p[j], p[k]) == COUNTER_CLOCKWISE;
}
if(cnt == 2) {
swap(p[i + 1], p[j]);
break;
}
}
}
bool intersect(const Segment& s) { // ??????s??¨????????¢????°?????????¨???1??????????????????????????°true
bool flag = false;
rep(i, 4) flag |= ::intersect(s, Segment(p[i], p[(i + 1) % 4]));
return flag;
}
bool contain(const Point& pp) { // ???pp???????????¢????????????????????°(??????????????????)true
bool flag = true;
rep(i, 4) flag &= ccw(p[i], p[(i + 1) % 4], pp) == COUNTER_CLOCKWISE;
return flag;
}
bool contain(const Segment& s) { // ??????s???????????¢????????????????????°(??????????????????)true
return contain(s.p1) && contain(s.p2);
}
};
const int MAX_N = 210;
using TYPE = double; // ?????¢???????????\??????
vector<pair<int, TYPE> > G[MAX_N];
vector<TYPE> dijkstra(int start){
vector<TYPE> dist(MAX_N, INFF);
dist[start] = 0;//dist[i] :=???start->i?????§??????????????¢
priority_queue<pair<TYPE, int>, vector<pair<TYPE, int> >, greater<pair<TYPE, int> > > que;
que.push(make_pair(0, start));
while(!que.empty()){
TYPE cost; int u;//????????§???????????£????????? ?????¨?????????
cost = que.top().first, u = que.top().second;
que.pop();
if(dist[u] < cost) continue;
for (auto tmp : G[u]){
int v = tmp.first; TYPE time = tmp.second;//??£??\???????????? ?????????????????§????????????
if(dist[v] > dist[u] + time){//u->v
dist[v] = dist[u] + time;
que.push(make_pair(dist[v], v));
}
}
}
return dist;
}
int main(void) {
while(1) {
int N; scanf("%d", &N);
if(N == 0) break;
int NV[110], H[110];
vector<vector<pair<double, double>>> p;
rep(i, N){
scanf("%d %d", &NV[i], &H[i]);
vector<pair<double, double>> tmp;
rep(j, NV[i]){
double x, y; scanf("%lf %lf", &x, &y);
tmp.pb(mp(x, y));
}
p.pb(tmp);
}
double theta, phi; scanf("%lf %lf", &theta, &phi);
double Sx, Sy, Tx, Ty; scanf("%lf %lf %lf %lf", &Sx, &Sy, &Tx, &Ty);
Point start(Sx, Sy), goal(Tx, Ty);
vector<Polygon> v;
rep(i, N){
Polygon t;
for(auto u : p[i]) t.pb(Shadow(u.fi, u.se, H[i], theta, phi));
for(auto u : p[i]) t.pb(Point(u.fi, u.se));
Polygon tt = andrewScan(t);
v.pb(tt);
}
/*
for(auto u : v) {
for(auto k : u) printf("%f %f, ", k.x, k.y);
printf("\n");
}
*/
rep(i, MAX_N) G[i].clear();
rep(i, v.size())rep(j, v.size()){
if(i == j) continue;
int s = i + 1, t = j + 1;
auto dis = getDistancePolPol(v[i], v[j]);
G[s].pb(mp(t, dis)), G[t].pb(mp(s, dis));
}
rep(i, v.size()){
auto dis = getDistancePolP(v[i], start);
G[0].pb(mp(i + 1, dis)), G[i + 1].pb(mp(0, dis));
}
rep(i, v.size()){
auto dis = getDistancePolP(v[i], goal);
G[N + 1].pb(mp(i + 1, dis)), G[i + 1].pb(mp(N + 1, dis));
}
G[0].pb(mp(N + 1, getDistance(start, goal))), G[N + 1].pb(mp(0, getDistance(start, goal)));
auto ret = dijkstra(0);
printf("%.9f\n", ret[N + 1]);
}
return 0;
}
|
F: Grid number
problem
Ebi-chan is trying to write exactly one integer from 1 to 2 \ times n in a grid with n columns horizontally and 2 rows vertically.
Only one integer can be written to each cell in the grid.
It's not fun just to write normally, so I set the following rules.
* The absolute value of the difference between the integers written in two adjacent cells is less than or equal to k.
* When there is a cell to the right of a cell, the integer written to the cell is truly smaller than the integer written to the cell to the right.
* When there is a cell under a cell, the integer written in the cell is truly smaller than the integer written in the cell below.
Here, two adjacent squares represent squares that share the top, bottom, left, and right sides with a certain square.
How many ways to write this? The answer can be very large, so print the remainder after dividing by the prime number m.
Supplement
The second and third rules above require you to write an integer so that it doesn't violate the inequality sign, as shown in the figure below.
<image>
Input format
You will be given three integers as input.
n k m
Constraint
* 1 \ leq n \ leq 100
* 1 \ leq k \ leq 10
* 2 \ leq m \ leq 10 ^ 9 + 7
* m is a prime number
Output format
Please output the number on one line according to how to write the number. Also, be careful not to forget the trailing line break.
Input example 1
3 2 7
Output example 1
1
<image>
* The above writing method meets the conditions, and there is no other writing method that meets the conditions.
Input example 2
5 10 11
Output example 2
9
* Output the remainder divided by m.
Example
Input
3 2 7
Output
1
|
#include <iostream>
using namespace std;
typedef long long int ll;
ll mod;
ll dp[2][201][11][(1<<11)];
int main(){
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N,K; cin >> N >> K >> mod;
dp[0][0][1][1]=1;
int kk=(1<<(1+K));
for(int _=0;_<N;_++){
for(int i=0;i<=2*N;i++){
for(int j=0;j<=K;j++){
for(int k=0;k<kk;k++){
dp[1][i][j][k]=0;
}
}
}
for(int i=0;i<2*N;i++){
for(int j=1;j<=K;j++){
for(int k=0;k<kk;k++){
if(dp[0][i][j][k]==0)continue;
int t=0;
while((k>>t)&1)t++;
if(t>K)continue;
int ii=i+t;
int kkk=(k>>t)+1;
for(int jj=1;jj<=K;jj++){
if((kkk>>jj)&1)continue;
if(ii+jj-i-j>K)continue;
if(i+j<ii+jj&&ii+jj<=2*N)(dp[1][ii][jj][kkk|(1<<jj)]+=dp[0][i][j][k])%=mod;
}
}
}
}
for(int i=0;i<=2*N;i++){
for(int j=1;j<=K;j++){
for(int k=0;k<kk;k++){
dp[0][i][j][k]=dp[1][i][j][k];
}
}
}
}
ll ans=0;
for(int i=0;i<2*N;i++){
for(int j=1;j<=K;j++){
for(int k=0;k<kk;k++){
(ans+=dp[0][i][j][k])%=mod;
}
}
}
cout << ans << endl;
}
|
Earthquakes
E869120 You are not good at earthquakes.
Specifically, if an earthquake with a seismic intensity of $ p $ occurs while you are doing a task, the performance of that task will be reduced by $ 10 \ times p $ percent.
Yesterday, there were $ N $ earthquakes. More specifically, yesterday's i-th earthquake occurred at time $ T_i $, with a seismic intensity of $ A_i $.
Here you will be given $ Q $ questions. The contents of the $ i $ question are as follows.
* E869120 When you work from time $ L_i $ to time $ R_i $, what is the final work performance value?
However, the performance at the start of work is $ 1000000000 \ (= 10 ^ 9) $, and there is nothing that affects the performance of the work other than the earthquake.
In addition, there is no earthquake at the beginning and end of the work.
input
Input is given from standard input in the following format.
$ N $
$ T_1 $ $ A_1 $
$ T_2 $ $ A_2 $
$ T_3 $ $ A_3 $
$ \ ldots $
$ T_N $ $ A_N $
$ Q $
$ L_1 $ $ R_1 $
$ L_2 $ $ R_2 $
$ L_3 $ $ R_3 $
$ \ ldots $
$ L_Q $ $ R_Q $
output
Output the answers to questions $ 1, 2, 3, \ dots, Q $ in this order, separated by line breaks.
However, insert a line break at the end.
If the absolute error or relative error from the assumed answer is within $ 10 ^ {-7} $, it is judged to be the correct answer.
Constraint
* $ 1 \ leq N \ leq 100000 \ (= 10 ^ 5) $
* $ 1 \ leq Q \ leq 100000 \ (= 10 ^ 5) $
* $ 0 \ leq A_i \ leq 7 $
* $ 1 \ leq T_1 <T_2 <\ cdots <T_N \ leq 1000000000 \ (= 10 ^ 9) $
* $ 1 \ leq L_i <R_i \ leq 1000000000 \ (= 10 ^ 9) $
* No input will be given to cause an earthquake at the work start time or work end time.
* All inputs are integers.
Input example 1
3
3 3
5 4
8 1
2
14
4 9
Output example 1
700000000.000000000000
539999999.999999880791
For any question, if the output value is within $ 10 ^ {-7} $ in absolute or relative error from the actual answer value, it will be judged as correct.
Input example 2
3
3 1
41 5
92 6
2
5 35
8 97
Output example 2
1000000000.000000000000
200000000.000000059605
Input example 3
Ten
176149409 6
272323398 6
280173589 0
374879716 5
402263621 5
498152735 0
639318228 6
641750638 3
764022785 2
939252868 5
Ten
40529600 224871240
537110257 584835100
409292125 704323206
674752453 740931787
511335734 793975505
320036645 530705208
527941292 660218875
326908007 473745741
428255750 654430923
590875206 623136989
Output example 3
400000000.000000000000
1000000000.000000000000
280000000.000000059605
1000000000.000000000000
224000000.000000089407
250000000.000000000000
280000000.000000059605
250000000.000000000000
280000000.000000059605
1000000000.000000000000
Example
Input
3
3 3
5 4
8 1
2
1 4
4 9
Output
700000000.000000000000
539999999.999999880791
|
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const int INF=0x3f3f3f3f;
const ll INFL=0x3f3f3f3f3f3f3f3f;
const int MOD=1000000007;
int t[200000],a[200000];
ll s[8][200000];
int main(){
int n;cin>>n;
vector<int>xs;
rep(i,n){
scanf("%d%d",&t[i],&a[i]);
rep(j,8){
s[j][i+1]=s[j][i];
if(j==a[i])s[j][i+1]++;
}
xs.push_back(t[i]);
}
int q;cin>>q;
rep(i,q){
int l,r;scanf("%d%d",&l,&r);
int R=lower_bound(xs.begin(),xs.end(),r)-xs.begin();
int L=lower_bound(xs.begin(),xs.end(),l)-xs.begin();
double ans=1e9;
rep(j,8){
int cnt=s[j][R]-s[j][L];
ans*=pow((10-j)/10.,cnt);
}
printf("%.12lf\n",ans);
}
}
|
For a given weighted graph G(V, E) and a source r, find the source shortest path to each vertex from the source (SSSP: Single Source Shortest Path).
Constraints
* 1 ≤ |V| ≤ 100000
* 0 ≤ di ≤ 10000
* 0 ≤ |E| ≤ 500000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
Print the costs of SSSP in the following format.
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print INF.
Examples
Input
4 5 0
0 1 1
0 2 4
1 2 2
2 3 1
1 3 5
Output
0
1
3
4
Input
4 6 1
0 1 1
0 2 4
2 0 1
1 2 2
3 1 1
3 2 5
Output
3
0
2
INF
|
from heapq import heappush, heappop
INF = 10**10
a,b,c = map(int,input().split())
d = [[] for i in range(a)]
for i in range(b):
ta,tb,tc = map(int,input().split())
d[ta].append((tb,tc))
def dijkstra(N, G, s):
dist = [INF] * N
que = [(0, s)]
dist[s] = 0
while que:
c, v = heappop(que)
if dist[v] < c:
continue
for t, cost in G[v]:
if dist[v] + cost < dist[t]:
dist[t] = dist[v] + cost
heappush(que, (dist[t], t))
for i in range(a):
print(dist[i] if dist[i] < INF else "INF")
dijkstra(a,d,c)
|
At last, we have successfully neutralized all the cyber weapons of mass destruction, saved our university along the way and lay to waste another evil scheme in the process. All that separates that hacker from us now is his last lair of security, his ultimate firewall. It is imperative for us to break through this last line of defense and punish the one responsible for all this loss. Breaking this firewall shall be no easy task, but we aren't letting go either. Shift your gears in reverse and get cracking.
Input:
TThe first line will consist of the total number of test cases T.
The next T lines will consist of number N on each line where 1 ≤ N ≤ 100.
Output:
For each test case, output is a number.
Example:
Input:
3
2
12
44
Output:
8
96
11264
|
for i in xrange(input()):
x=input()
s=0
y=x
while x>0:
s+=x%10
x/=10
print y*pow(2,s)
|
AND gates and OR gates are basic components used in building digital circuits. Both gates have two input lines and one output line. The output of an AND gate is 1 if both inputs are 1, otherwise the output is 0. The output of an OR gate is 1 if at least one input is 1, otherwise the output is 0.
You are given a digital circuit composed of only AND and OR gates where one node (gate or input) is specially designated as the output. Furthermore, for any gate G and any input node I, at most one of the inputs to G depends on the value of node I.
Now consider the following random experiment. Fix some probability p in [0,1] and set each input bit to 1 independently at random with probability p (and to 0 with probability 1-p). The output is then 1 with some probability that depends on p. You wonder what value of p causes the circuit to output a 1 with probability 1/2.
Input
The first line indicates the number of test cases to follow (about 100).
Each test case begins with a single line containing a single integer n with 1 ≤ n ≤ 100 indicating the number of nodes (inputs and gates) in the circuit. Following this, n lines follow where the i'th line describes the i'th node. If the node is an input, the line simply consists of the integer 0. Otherwise, if the node is an OR gate then the line begins with a 1 and if the node is an AND gate then the line begins with a 2. In either case, two more integers a,b follow, both less than i, which indicate that the outputs from both a and b are used as the two input to gate i.
As stated before, the circuit will be such that no gate has both of its inputs depending on the value of a common input node.
Test cases are separated by a blank line including a blank line preceding the first test case.
Output
For each test case you are to output a single line containing the value p for which the output of node n is 1 with probability exactly 1/2 if the inputs are independently and randomly set to value 1 with probability p. The value p should be printed with exactly 5 digits after the decimal.
Example
Input:
4
1
0
3
0
0
1 1 2
3
0
0
2 1 2
5
0
0
0
2 1 2
1 3 4
Output:
0.50000
0.29289
0.70711
0.40303
|
def circuits():
t=int(raw_input())
for i in range(t):
n=raw_input()
n=int(raw_input())
inp=[]
in1=[]
in2=[]
for j in range(n):
x=raw_input().split()
inp.append(int(x[0]))
if x[0]=='0':
in1.append(0)
in2.append(0)
else:
in1.append(int(x[1]))
in2.append(int(x[2]))
lowp=0
hip=1
q=1
j=0
while(abs(q)>0.0000001):
x=[]
p=(lowp+hip)/2.0
for k in range(n):
if inp[k]==0:
x.append(p)
elif inp[k]==1:
x.append(1-(1-x[in1[k]-1])*(1-x[in2[k]-1]))
else:
x.append((x[in1[k]-1])*(x[in2[k]-1]))
q=x[n-1]-0.5
if x[n-1]<0.5:
lowp=p
if x[n-1]>0.5:
hip=p
j=j+1
print "%.5f" %p
if __name__=="__main__":
circuits()
|
Problem Description
An online quiz is going to be held at NIT Hamirpur. Each student will be given a system which is connected to internet. Although all the systems are connected to same network, there is still varying data transfer speed among them. This can cause pages to load slower on one system than the other. The organizers do not want a participant to have an advantage over others due to this. The organizers can't increase transfer speed on a system but they can cap it. Also they want to provide maximum speed to each system.
Suppose there are n systems and m participants and speed of each of the n systems is known. Your task is to tell them the maximum speed they should keep on each system, so that atleast m of n systems have the same speed.
Input
First line containing two space separated inputs (n and m) - the number of computer and participants respectively. The next line contains a space separated sequence of n integers: a1, a2, ..., an - where ai denotes the speed of i^th computer in KB/s.
Output
Print a single integer representing the maximum data transfer speed that should be kept.
Constraints
Should contain all the constraints on the input data that you may have. Format it like:
1 ≤ n ≤ 200
1 ≤ m ≤ n
Example
Input:
5 3
250 125 330 3000 1000
Output:
330
Input:
6 6
2000 2100 3000 1500 1250 3000
Output:
1250
|
l=[int(i) for i in raw_input().split()];
n=l[0];
m=l[1];
l=[int(i) for i in raw_input().split()];
l.sort();
l=l[::-1];
print l[m-1];
|
Once N boys and M girls attended a party. You are given a matrix A of N rows and M columns where Aij is 1 if the i-th boy likes the j-th girl, otherwise it will be 0. Note that it is not necessary that if a boy x likes girl y, then girl y should like boy x.
You know that if there are two different boys x and y, who both like girl z, then there will be a collision.
Can you calculate the number of different collisions at this party? Note that order of boys in the collision doesn't matter.
Input
The first line contains a single integer T denoting the number of test cases. Then T test cases follow.
The first line of each test case contains two space separated integers N, M denoting the number of boys and girls, respectively.
Each of the following N lines contain M characters, each of them is either '0' or '1'.
Output
For each test case output a single line containing an integer corresponding to the number of collisions at the party.
Constraints
1 ≤ T ≤ 100
1 ≤ N, M ≤ 10
Example
Input:
2
4 3
111
100
110
000
2 2
10
01
Output:
4
0
Explanation
Example Case 1. All three boys like the first girl, so there are (1, 2, 1), (1, 3, 1), (2, 3, 1) collisions with her. Boys 1 and 3 both like the second girl so this is one more collision. Only one boy likes the third girl, so there are no collisions with her and thus we have 4 collisions total.
Example Case 2. For each girl there is only one boy who likes her, so there are no collisions at all.
|
# @author Kilari Teja
# LCOLLIS
for Indx in range(0, int(raw_input())):
Collisions = 0
Dims = [int(Dim) for Dim in (raw_input()).split(" ")]
Cols = [[] for CIndx in range(0, Dims[1])]
for RIndx in range(0, Dims[0]):
Row = raw_input()
for Chr in range(0, Dims[1]):
Cols[Chr].append(Row[Chr])
for Col in Cols:
Occour = Col.count('1')
for S in range(1, Occour):
Collisions = Collisions + S
print Collisions
|
Recently, Chef got obsessed with piano. He is a just a rookie in this stuff and can not move his fingers from one key to other fast enough. He discovered that the best way to train finger speed is to play scales.
There are different kinds of scales which are divided on the basis of their interval patterns. For instance, major scale is defined by pattern T-T-S-T-T-T-S, where ‘T’ stands for a whole tone whereas ‘S’ stands for a semitone. Two semitones make one tone. To understand how they are being played, please refer to the below image of piano’s octave – two consecutive keys differ by one semitone.
If we start playing from first key (note C), then we’ll play all white keys in a row (notes C-D-E-F-G-A-B-C – as you can see C and D differ for a tone as in pattern, and E and F differ for a semitone).
This pattern could be played some number of times (in cycle).
Each time Chef takes some type of a scale and plays using some number of octaves. Sometimes Chef can make up some scales, so please don’t blame him if you find some scale that does not exist in real world.
Formally, you have a set of 12 keys (i.e. one octave) and you have N such sets in a row. So in total, you have 12*N keys. You also have a pattern that consists of letters 'T' and 'S', where 'T' means move forward for two keys (from key x to key x + 2, and 'S' means move forward for one key (from key x to key x + 1).
Now, you can start playing from any of the 12*N keys. In one play, you can repeat the pattern as many times as you want, but you cannot go outside the keyboard.
Repeating pattern means that if, for example, you have pattern STTST, you can play STTST as well as STTSTSTTST, as well as STTSTSTTSTSTTST, as well as any number of repeating. For this pattern, if you choose to repeat it once, if you start at some key x, you'll press keys: x (letter 'S')-> x + 1 (letter 'T')-> x + 3 (letter 'T')-> x + 5 (letter 'S') -> x + 6 (letter 'T')-> x + 8. Also 1 ≤ x, x + 8 ≤ 12*N so as to avoid going off the keyboard.
You are asked to calculate number of different plays that can be performed. Two plays differ if and only if they start at different keys or patterns are repeated different number of times.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
First line of each test case contains scale’s pattern – string s consisting of letters ‘T’ and ‘S’ only.
Second line contains one integer N – number of octaves he’ll be using.
Output
For each test case output a single number in a line corresponding to number of different scales he’ll play.
Constraints
1 ≤ T ≤ 10^5
1 ≤ |S| ≤ 100
1 ≤ n ≤ 7
Example
Input:
2
TTTT
1
TTSTTTS
3
Output:
4
36
Explanation
Example case 1. In the first case there is only one octave and Chef can play scale (not in cycle each time) starting with notes C, C#, D, D# - four together.
|
for _ in range(input()):
s=raw_input()
n=input()
t,sum=0,0
for i in s:
if i=='T':
sum+=2
#print t
else:
sum+=1
#sum=t+st
#print sum
temp=12*n
j,i,c=temp,1,0
while i<=temp:
j=temp-i
while j:
j-=sum
if j>=0:
c+=1
if j-sum<0:
break
i+=1
if temp-i<sum:
break
print c
|
John's barn has a fence consisting of N consecutive parts numbered from left to right starting from 1 to N. Each part is initially painted in one of two colors: red or green, whose information is provided you by a string C. The color of i-th part Ci will be equal to 'R' if the color of the part is red and 'G' if it is green.
John decided to paint the whole fence in green color. To make the mundane process of painting more entertaining he decided to do it using the following process.
Every minute (until the whole fence is painted green) he will do the following steps:
Choose any part of the fence that is painted red. Let's denote the index of this part as X.
For each part with indices X, X+1, ..., min(N, X + K - 1), flip the color of the corresponding part from red to green and from green to red by repainting.
John is wondering how fast he can repaint the fence. Please help him in finding the minimum number of minutes required in repainting.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains the two integers N and K.
The next line contains the string C.
Output
For each test case, output a single line containing the answer to the corresponding test case.
Constraints
1 ≤ T ≤ 10
1 ≤ N, K ≤ 10^5
C will consist only of uppercase English characters 'R' and 'G'.
Example
Input:
1
7 3
RGGRGRG
Output:
4
Explanation
Example case 1. One optimal solution (with 4 steps) looks like this:
Choose the 1-st character (1-based index) and get "GRRRGRG".
Choose the 2-st character (1-based index) and get "GGGGGRG".
Choose the 6-th character (1-based index) and get "GGGGGGR".
Choose the 7-th charatcer (1-based index) and get "GGGGGGG".
Now repainting is done :) It took total 4 steps. Hence answer is 4.
|
t = int(raw_input())
for i in range(t):
n,k = [int(j) for j in raw_input().split()]
c = raw_input()
l = list(c)
q = []
qf,qb = 0,0
j,co = 0,0
while j < n:
if (qb-qf)%2 == 0:
if l[j] == 'R':
co += 1
q.append(min(n,j+k))
qb += 1
else:
if l[j] == 'G':
co += 1
q.append(min(n,j+k))
qb += 1
if qb-qf > 0 and q[qf] == j+1:
qf += 1
j += 1
print co
|
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000
|
import java.util.Scanner;
public class Code {
public static long distSum(int n)
{
long sum=0;
int i,j=n/2;
for(i=0;i<n;i++)
{
sum=sum+ Math.abs(i-j);
}
return sum;
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n=in.nextInt();
int m=in.nextInt();
long ans=0;
int i;
long distSum=distSum(n);
//if(n%2==0)distSum+=n/2;
// long neg = ((n - 1) / 2) * (long)((n - 1) / 2 + 1);
//if (n % 2 == 0) neg += n / 2;
for(i=0;i<m;i++)
{
long x=in.nextInt();
long d=in.nextInt();
ans+=n*x;
if(d>0)
{
ans+= d*n*(n-1)/2;
}
else
{
ans+=d*distSum;
}
}
System.out.println((double)ans/n);
}
}
|
You are given two positive integers a and b. There are two possible operations:
1. multiply one of the numbers by some prime p;
2. divide one of the numbers on its prime factor p.
What is the minimum number of operations required to obtain two integers having the same number of divisors? You are given several such pairs, you need to find the answer for each of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of pairs of integers for which you are to find the answer.
Each of the next t lines contain two integers a_i and b_i (1 ≤ a_i, b_i ≤ 10^6).
Output
Output t lines — the i-th of them should contain the answer for the pair a_i, b_i.
Example
Input
8
9 10
100 17
220 70
17 19
4 18
32 20
100 32
224 385
Output
1
3
1
0
1
0
1
1
Note
These are the numbers with equal number of divisors, which are optimal to obtain in the sample test case:
* (27, 10), 4 divisors
* (100, 1156), 9 divisors
* (220, 140), 12 divisors
* (17, 19), 2 divisors
* (12, 18), 6 divisors
* (50, 32), 6 divisors
* (224, 1925), 12 divisors
Note that there can be several optimal pairs of numbers.
|
#include <bits/stdc++.h>
using namespace std;
struct block {
int id;
vector<int> factors_vector;
int divisor;
};
block different_blocks[1000];
int no_of_different_blocks = 0;
int no_of_different_divisors = 0;
bool v[1000009];
long long primes[1000009];
int n_primes;
int tmp[1000];
void pre_process();
int sieve();
int fn(int current, long long with_me, int beforeCnt);
int make_array_of_different_divisors();
int get_number_index_in_block_array(int x);
const int inf = 99999999;
int blocks_divisors_array[1000][1000];
vector<int> numPF(long long x);
map<int, int> different_divisors;
int solve(int x, int y);
int get_block_differences(vector<int> x, vector<int> y);
int p = 0;
int main() {
pre_process();
if (p) {
for (map<int, int>::iterator it = different_divisors.begin();
it != different_divisors.end(); it++) {
pair<int, int> x = *it;
printf("the catast %d %d\n", x.first, x.second);
}
for (int i = 0; i < no_of_different_blocks; i++) {
{
printf("the another vector \n");
for (int h = 0; h < different_blocks[i].factors_vector.size(); h++)
printf("%d ", different_blocks[i].factors_vector[h]);
printf("\n");
}
}
}
int tc;
scanf("%d", &tc);
for (int i = 0; i < tc; i++) {
int x, y;
scanf("%d %d", &x, &y);
printf("%d\n", solve(x, y));
if (p) {
vector<int> g;
g.push_back(1);
g.push_back(2);
g.push_back(4);
vector<int> t;
t.push_back(0);
printf("ijiojiooij yuguyfuyfutfu %d\n", get_block_differences(g, t));
}
}
return 0;
}
int solve(int x, int y) {
int x_index = get_number_index_in_block_array(x);
int y_index = get_number_index_in_block_array(y);
if (p) {
printf(" index %d %d\n", x_index, y_index);
printf(" the deiv %d %d\n", different_blocks[x_index].divisor,
different_blocks[y_index].divisor);
}
int ret = inf;
for (map<int, int>::iterator it = different_divisors.begin();
it != different_divisors.end(); it++) {
pair<int, int> x = *it;
int div_index = x.second;
if (p) {
printf("=========== %d %d %d the index %d\n", x.first,
blocks_divisors_array[x_index][div_index],
blocks_divisors_array[y_index][div_index], div_index);
}
if (p) {
}
ret = min(ret, blocks_divisors_array[x_index][div_index] +
blocks_divisors_array[y_index][div_index]);
}
return ret;
}
void pre_process() {
n_primes = sieve();
no_of_different_blocks = fn(0, 1, 70);
no_of_different_divisors = make_array_of_different_divisors();
block x;
x.id = no_of_different_blocks;
int div = 1;
x.factors_vector.push_back(0);
sort(x.factors_vector.begin(), x.factors_vector.end());
x.divisor = div;
different_blocks[no_of_different_blocks++] = x;
for (int i = 0; i < no_of_different_blocks; i++)
for (int j = 0; j < no_of_different_divisors; j++)
blocks_divisors_array[i][j] = inf;
for (int i = 0; i < no_of_different_blocks; i++) {
for (int j = 0; j < no_of_different_blocks; j++) {
{
int x = get_block_differences(different_blocks[i].factors_vector,
different_blocks[j].factors_vector);
int div = different_blocks[j].divisor;
int indx = different_divisors[div];
blocks_divisors_array[i][indx] = min(blocks_divisors_array[i][indx], x);
if (p) {
if (div == 144 && different_blocks[i].factors_vector.size() == 3 &&
different_blocks[i].factors_vector[0] == 2 &&
different_blocks[i].factors_vector[1] == 3 &&
different_blocks[i].factors_vector[2] == 10 && x == 1) {
printf("THE TARGRT IS THE %d\n", x);
for (int h = 0; h < different_blocks[j].factors_vector.size(); h++)
printf("%d, ", different_blocks[j].factors_vector[h]);
}
if (i == 60 && div == 1) {
printf("checking the div %d %d index %d\n", div, x, indx);
}
}
}
}
}
if (p)
printf("%d %d %d opopopopopopoooppooppopopooppopopopopopopopopopopo\n",
no_of_different_divisors, no_of_different_blocks, n_primes);
}
int get_block_differences(vector<int> x, vector<int> y) {
int i = x.size() - 1, j = y.size() - 1;
int ret = 0;
sort(x.begin(), x.end());
sort(y.begin(), y.end());
while (i >= 0 || j >= 0) {
if (i < 0)
ret += y[j];
else if (j < 0)
ret += x[i];
else
ret += abs(x[i] - y[j]);
i--, j--;
}
return ret;
}
int get_number_index_in_block_array(int x) {
vector<int> prime_dist = numPF(x);
if (p) printf("joijio %d %d %d\n", x, prime_dist.size(), prime_dist[0]);
for (int i = 0; i < no_of_different_blocks; i++) {
if (p) {
printf("the another vector \n");
for (int h = 0; h < different_blocks[i].factors_vector.size(); h++)
printf("%d ", different_blocks[i].factors_vector[h]);
printf("\n");
}
if (different_blocks[i].factors_vector == prime_dist) {
if (p) {
printf("the vector \n");
for (int h = 0; h < prime_dist.size(); h++)
printf("%d ", prime_dist[h]);
printf("\n");
}
return i;
}
}
return -1;
}
vector<int> numPF(long long x) {
int i = 0;
vector<int> ret;
if (x == 1) {
ret.push_back(0);
return ret;
}
long long pf = primes[i++];
while (x != 1 && i < n_primes && x >= pf * pf) {
int cnt = 0;
while (x % pf == 0) {
x /= pf;
cnt++;
}
if (cnt) ret.push_back(cnt);
pf = primes[i++];
}
if (x != 1) ret.push_back(1);
sort(ret.begin(), ret.end());
return ret;
}
int fn(int current, long long with_me, int beforeCnt) {
int x = 60;
if (with_me > 1) {
if (p) {
if (current == 1 && with_me == 256 && beforeCnt == 8)
printf("winwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww\n");
}
block x;
x.id = no_of_different_blocks;
int div = 1;
for (int i = 0; i < current; i++)
x.factors_vector.push_back(tmp[i]), div = div * (tmp[i] + 1);
if (p)
if (div == 243) {
printf(
"BBBBBBBBBBBBBBBBBBBBBBOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOMMMM"
"MMMMMMMMMMMM\n");
for (int j = 0; j < current; j++) printf("%d ", tmp[j]);
printf("\n");
}
sort(x.factors_vector.begin(), x.factors_vector.end());
x.divisor = div;
different_blocks[no_of_different_blocks++] = x;
}
if (current == n_primes || with_me * primes[current] > 1000009 * x) {
return 1;
}
long long local = 1;
int ret = 0;
for (int i = 1; i <= beforeCnt && with_me * local < 1000009 * x; i++) {
if (p) {
if (current == 0)
printf(
"------------------------------------------------------------------"
"------------- %d\n",
i);
}
local *= primes[current];
if (with_me * local >= 1000009 * x) break;
tmp[current] = i;
ret += fn(current + 1, with_me * local, i);
}
return ret + 1;
}
int sieve() {
memset(v, 0, sizeof(v));
v[0] = v[1] = 1;
long long i, j;
for (i = 2; i * i < 1000009; i++) {
if (!v[i]) {
for (j = i * i; j < 1000009; j += i) {
v[j] = 1;
}
}
}
int index = 0;
for (i = 2; i < 1000009; i++) {
if (!v[i]) {
primes[index++] = i;
}
}
return index;
}
int make_array_of_different_divisors() {
set<int> divisors_set;
for (int i = 0; i < no_of_different_blocks; i++)
divisors_set.insert(different_blocks[i].divisor);
divisors_set.insert(1);
int j = 0;
for (set<int>::iterator it = divisors_set.begin(); it != divisors_set.end();
it++) {
int x = *it;
pair<int, int> s;
s.first = x;
s.second = j;
different_divisors.insert(s);
if (p) {
printf("before %d %d\n", x, j);
}
j++;
}
return divisors_set.size();
}
|
Pasha is a young technician, nevertheless, he has already got a huge goal: to assemble a PC. The first task he has to become familiar with is to assemble an electric scheme.
The scheme Pasha assembled yesterday consists of several wires. Each wire is a segment that connects two points on a plane with integer coordinates within the segment [1, 10^9].
There are wires of two colors in the scheme:
* red wires: these wires are horizontal segments, i.e. if such a wire connects two points (x_1, y_1) and (x_2, y_2), then y_1 = y_2;
* blue wires: these wires are vertical segments, i.e. if such a wire connects two points (x_1, y_1) and (x_2, y_2), then x_1 = x_2.
Note that if a wire connects a point to itself, it may be blue, and it can be red. Also, in Pasha's scheme no two wires of the same color intersect, i.e. there are no two wires of same color that have common points.
The imperfection of Pasha's scheme was that the wires were not isolated, so in the points where two wires of different colors intersect, Pasha saw sparks. Pasha wrote down all the points where he saw sparks and obtained a set of n distinct points. After that he disassembled the scheme.
Next morning Pasha looked at the set of n points where he had seen sparks and wondered how many wires had he used. Unfortunately, he does not remember that, so he wonders now what is the smallest number of wires he might have used in the scheme. Help him to determine this number and place the wires in such a way that in the resulting scheme the sparks occur in the same places.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of points where Pasha saw sparks.
Each of the next n lines contain two integers x and y (1 ≤ x, y ≤ 10^9) — the coordinates of a point with sparks. It is guaranteed that all points are distinct.
Output
Print the description of the scheme in the following format.
In the first line print h — the number of horizontal red wires (0 ≤ h). In each of the next h lines print 4 integers x_1, y_1, x_2, y_2 — the coordinates of two points (x_1, y_1) and (x_2, y_2) that are connected with this red wire. The segmenst must be horizontal, i.e. y_1 = y_2 must hold. Also, the constraint 1 ≤ x_1, y_1, x_2, y_2 ≤ 10^9 must hold.
After that print v — the number of vertical blue wires (0 ≤ v). In each of the next v lines print 4 integers x_1, y_1, x_2, y_2 — the coordinates of two points (x_1, y_1) and (x_2, y_2) that are connected with this blue wire. The segmenst must be vertical, i.e. x_1 = x_2 shomustuld hold. Also, the constraint 1 ≤ x_1, y_1, x_2, y_2 ≤ 10^9 must hold.
No two segments of the same color should have common points. The set of points where sparks appear should be the same as given in the input.
The number of segments (h + v) should be minimum possible. It's easy to see that the answer always exists. If there are multiple possible answers, print any.
Examples
Input
4
2 2
2 4
4 2
4 4
Output
2
5 2 1 2
1 4 5 4
2
2 1 2 5
4 5 4 1
Input
4
2 1
3 2
2 3
1 2
Output
4
2 1 2 1
3 2 3 2
1 2 1 2
2 3 2 3
3
1 2 1 2
3 2 3 2
2 3 2 1
Note
In the first example Pasha could have assembled the following scheme:
<image>
In this scheme there are 2 wires of each color: red ones connecting (5, 2) with (1, 2) and (1, 4) with (5, 4), blue ones connecting (2, 1) with (2, 5) and (4, 5) with (4, 1). Note that the sparks appear in the points that are described in the input, they are shown in yellow on the picture. For example, Pasha will see the spark in the point (2, 4) because the second red wire and the first blue wire intersect there. It is possible to show that we can't have less than 4 wires to produce a scheme with same sparks positions.
|
#include <bits/stdc++.h>
using namespace std;
struct VerSeg {
int x, y_1, y_2;
VerSeg(int x_, int y_1_, int y_2_) : x(x_), y_1(y_1_), y_2(y_2_) {}
VerSeg() {}
};
struct HorSeg {
int y, x_1, x_2;
HorSeg(int y_, int x_1_, int x_2_) : y(y_), x_1(x_1_), x_2(x_2_) {}
HorSeg() {}
};
vector<VerSeg> ver, versAns;
vector<HorSeg> hor, horsAns;
set<pair<int, int> > was;
const int MAX_N = 2e3 + 100;
int n, m, paired[2 * MAX_N], used[2 * MAX_N], maxIndependent[2 * MAX_N];
vector<int> g[MAX_N];
pair<int, int> a[MAX_N];
bool dfs(int v) {
if (used[v]) return false;
used[v] = 1;
for (int to : g[v])
if (paired[to] == -1 || dfs(paired[to])) {
paired[to] = v;
paired[v] = to;
return true;
}
return false;
}
int kuhn() {
int ans = 0;
for (int i = 0; (i) < (n + m); ++i) paired[i] = -1;
for (int run = 1; run;) {
run = 0;
memset(used, 0, sizeof(used));
for (int i = 0; (i) < (n); ++i)
if (!used[i] && paired[i] == -1 && dfs(i)) {
ans++;
run = 1;
}
}
return ans;
}
void dfsCoverIndependent(int v) {
if (used[v]) return;
used[v] = 1;
for (int to : g[v])
if (!used[to]) used[to] = 1, dfsCoverIndependent(paired[to]);
}
void findCoverIndependent() {
memset(used, 0, sizeof(used));
for (int i = 0; (i) < (n); ++i)
if (paired[i] == -1) dfsCoverIndependent(i);
for (int i = 0; (i) < (n); ++i)
if (used[i]) maxIndependent[i] = 1;
for (int i = (n); (i) < (n + m); ++i)
if (!used[i]) maxIndependent[i] = 1;
}
int main() {
int k;
scanf("%d", &k);
for (int i = 0; (i) < (k); ++i) {
scanf("%d%d", &a[i].first, &a[i].second);
}
sort(a, a + k);
for (int i = (1); (i) < (k); ++i)
if (a[i].first == a[i - 1].first) {
ver.push_back(VerSeg(a[i].first, a[i - 1].second, a[i].second));
}
for (int i = 0; (i) < (k); ++i) swap(a[i].first, a[i].second);
sort(a, a + k);
for (int i = 0; (i) < (k); ++i) swap(a[i].first, a[i].second);
for (int i = (1); (i) < (k); ++i)
if (a[i].second == a[i - 1].second) {
hor.push_back(HorSeg(a[i].second, a[i - 1].first, a[i].first));
}
n = (int)((ver).size()), m = (int)((hor).size());
for (int i = 0; (i) < (n); ++i)
for (int j = 0; (j) < (m); ++j) {
if (ver[i].y_1 < hor[j].y && ver[i].y_2 > hor[j].y &&
hor[j].x_1 < ver[i].x && hor[j].x_2 > ver[i].x)
g[i].push_back(n + j), g[n + j].push_back(i);
}
kuhn();
findCoverIndependent();
was.clear();
for (int i = 0; (i) < (n); ++i) {
if (maxIndependent[i]) {
int ind = n;
for (int j = (i); (j) < (n); ++j) {
if (!maxIndependent[j] || ver[j].x != ver[i].x) {
ind = j;
break;
}
was.insert(make_pair(ver[j].x, ver[j].y_1));
was.insert(make_pair(ver[j].x, ver[j].y_2));
}
versAns.push_back(VerSeg(ver[i].x, ver[i].y_1, ver[ind - 1].y_2));
i = ind - 1;
}
}
for (int i = 0; (i) < (k); ++i)
if (!was.count(a[i]))
versAns.push_back(VerSeg(a[i].first, a[i].second, a[i].second));
was.clear();
for (int i = 0; (i) < (m); ++i) {
if (maxIndependent[n + i]) {
int ind = m;
for (int j = (i); (j) < (m); ++j) {
if (!maxIndependent[n + j] || hor[j].y != hor[i].y) {
ind = j;
break;
}
was.insert(make_pair(hor[j].x_1, hor[j].y));
was.insert(make_pair(hor[j].x_2, hor[j].y));
}
horsAns.push_back(HorSeg(hor[i].y, hor[i].x_1, hor[ind - 1].x_2));
i = ind - 1;
}
}
for (int i = 0; (i) < (k); ++i)
if (!was.count(a[i]))
horsAns.push_back(HorSeg(a[i].second, a[i].first, a[i].first));
printf("%d\n", (int)((horsAns).size()));
for (auto seg : horsAns)
printf("%d %d %d %d\n", seg.x_1, seg.y, seg.x_2, seg.y);
printf("%d\n", (int)((versAns).size()));
for (auto seg : versAns)
printf("%d %d %d %d\n", seg.x, seg.y_1, seg.x, seg.y_2);
return 0;
}
|
Vova has taken his summer practice this year and now he should write a report on how it went.
Vova has already drawn all the tables and wrote down all the formulas. Moreover, he has already decided that the report will consist of exactly n pages and the i-th page will include x_i tables and y_i formulas. The pages are numbered from 1 to n.
Vova fills the pages one after another, he can't go filling page i + 1 before finishing page i and he can't skip pages.
However, if he draws strictly more than k tables in a row or writes strictly more than k formulas in a row then he will get bored. Vova wants to rearrange tables and formulas in each page in such a way that he doesn't get bored in the process. Vova can't move some table or some formula to another page.
Note that the count doesn't reset on the start of the new page. For example, if the page ends with 3 tables and the next page starts with 5 tables, then it's counted as 8 tables in a row.
Help Vova to determine if he can rearrange tables and formulas on each page in such a way that there is no more than k tables in a row and no more than k formulas in a row.
Input
The first line contains two integers n and k (1 ≤ n ≤ 3 ⋅ 10^5, 1 ≤ k ≤ 10^6).
The second line contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^6) — the number of tables on the i-th page.
The third line contains n integers y_1, y_2, ..., y_n (1 ≤ y_i ≤ 10^6) — the number of formulas on the i-th page.
Output
Print "YES" if Vova can rearrange tables and formulas on each page in such a way that there is no more than k tables in a row and no more than k formulas in a row.
Otherwise print "NO".
Examples
Input
2 2
5 5
2 2
Output
YES
Input
2 2
5 6
2 2
Output
NO
Input
4 1
4 1 10 1
3 2 10 1
Output
YES
Note
In the first example the only option to rearrange everything is the following (let table be 'T' and formula be 'F'):
* page 1: "TTFTTFT"
* page 2: "TFTTFTT"
That way all blocks of tables have length 2.
In the second example there is no way to fit everything in such a way that there are no more than 2 tables in a row and 2 formulas in a row.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
vector<int> x(n), y(n);
for (int& xi : x) cin >> xi;
for (int& yi : y) cin >> yi;
for (long long i = 0, px = 0, py = 0, qx, qy; i < n; ++i, px = qx, py = qy) {
qx = max(0LL, x[i] + px - y[i] * k);
qy = max(0LL, y[i] + py - x[i] * k);
if (qx > k || qy > k) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
return 0;
}
|
Alex decided to try his luck in TV shows. He once went to the quiz named "What's That Word?!". After perfectly answering the questions "How is a pseudonym commonly referred to in the Internet?" ("Um... a nick?"), "After which famous inventor we name the unit of the magnetic field strength?" ("Um... Nikola Tesla?") and "Which rock band performs "How You Remind Me"?" ("Um... Nickelback?"), he decided to apply to a little bit more difficult TV show: "What's in This Multiset?!".
The rules of this TV show are as follows: there are n multisets numbered from 1 to n. Each of them is initially empty. Then, q events happen; each of them is in one of the four possible types:
* 1 x v — set the x-th multiset to a singleton \\{v\}.
* 2 x y z — set the x-th multiset to a union of the y-th and the z-th multiset. For example: \{1, 3\}∪\{1, 4, 4\}=\{1, 1, 3, 4, 4\}.
* 3 x y z — set the x-th multiset to a product of the y-th and the z-th multiset. The product A × B of two multisets A, B is defined as \{ \gcd(a, b) ∣ a ∈ A, b ∈ B \}, where \gcd(p, q) is the greatest common divisor of p and q. For example: \{2, 2, 3\} × \{1, 4, 6\}=\{1, 2, 2, 1, 2, 2, 1, 1, 3\}.
* 4 x v — the participant is asked how many times number v occurs in the x-th multiset. As the quiz turned out to be too hard in the past, participants should now give the answers modulo 2 only.
Note, that x, y and z described above are not necessarily different. In events of types 2 and 3, the sum or the product is computed first, and then the assignment is performed.
Alex is confused by the complicated rules of the show. Can you help him answer the requests of the 4-th type?
Input
The first line contains two integers n and q (1 ≤ n ≤ 10^5, 1 ≤ q ≤ 10^6) — the number of multisets and the number of events.
Each of the following q lines describes next event in the format given in statement. It's guaranteed that 1 ≤ x,y,z ≤ n and 1 ≤ v ≤ 7000 always holds.
It's guaranteed that there will be at least one event of the 4-th type.
Output
Print a string which consists of digits 0 and 1 only, and has length equal to the number of events of the 4-th type. The i-th digit of the string should be equal to the answer for the i-th query of the 4-th type.
Example
Input
4 13
1 1 1
1 2 4
1 3 6
4 4 4
1 4 4
2 2 1 2
2 3 3 4
4 4 4
3 2 2 3
4 2 1
4 2 2
4 2 3
4 2 4
Output
010101
Note
Here is how the multisets look in the example test after each of the events; i is the number of queries processed so far:
<image>
|
#include <bits/stdc++.h>
using namespace std;
constexpr int kMaxN = 100000;
constexpr int kMaxValue = 7000;
constexpr int kBitSetSize = (kMaxValue + 1) / 64 + 1;
typedef long long BitSet[kBitSetSize];
void Add(BitSet a, BitSet b, BitSet c) {
for (int i = 0; i < kBitSetSize; ++i) {
c[i] = a[i] ^ b[i];
}
}
void Mult(BitSet a, BitSet b, BitSet c) {
for (int i = 0; i < kBitSetSize; ++i) {
c[i] = a[i] & b[i];
}
}
void Copy(BitSet a, BitSet b) {
for (int i = 0; i < kBitSetSize; ++i) {
b[i] = a[i];
}
}
int Parity(BitSet a) {
long long x = 0;
for (int i = 0; i < kBitSetSize; ++i) {
x ^= a[i];
}
int ret = 0;
for (int i = 0; i < 64; ++i) {
ret ^= (x >> i) & 1;
}
return ret;
}
void XorBit(int i, BitSet a) { a[i / 64] ^= 1LL << (i % 64); }
BitSet sum[kMaxN + 1];
BitSet singleton[kMaxValue + 1];
BitSet query[kMaxValue + 1];
int main() {
for (int i = 1; i <= kMaxValue; ++i) {
bool is_square_free = true;
for (int j = 1; j <= i; ++j) {
if (i % j == 0) {
XorBit(j, singleton[i]);
}
if (j > 1 && i % (j * j) == 0) {
is_square_free = false;
}
}
if (is_square_free) {
for (int j = 1; j * i <= kMaxValue; ++j) {
XorBit(j * i, query[j]);
}
}
}
int n, q;
scanf("%d%d", &n, &q);
for (int i = 0; i < q; ++i) {
int type = 0, x, y, z, v;
scanf("%d", &type);
if (type == 1) {
scanf("%d%d", &x, &v);
Copy(singleton[v], sum[x]);
} else if (type == 2) {
scanf("%d%d%d", &x, &y, &z);
Add(sum[y], sum[z], sum[x]);
} else if (type == 3) {
scanf("%d%d%d", &x, &y, &z);
Mult(sum[y], sum[z], sum[x]);
} else if (type == 4) {
scanf("%d%d", &x, &v);
static BitSet tmp;
Mult(sum[x], query[v], tmp);
printf("%d", Parity(tmp));
}
}
printf("\n");
return 0;
}
|
You are given an undirected tree of n vertices.
Some vertices are colored blue, some are colored red and some are uncolored. It is guaranteed that the tree contains at least one red vertex and at least one blue vertex.
You choose an edge and remove it from the tree. Tree falls apart into two connected components. Let's call an edge nice if neither of the resulting components contain vertices of both red and blue colors.
How many nice edges are there in the given tree?
Input
The first line contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of vertices in the tree.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2) — the colors of the vertices. a_i = 1 means that vertex i is colored red, a_i = 2 means that vertex i is colored blue and a_i = 0 means that vertex i is uncolored.
The i-th of the next n - 1 lines contains two integers v_i and u_i (1 ≤ v_i, u_i ≤ n, v_i ≠ u_i) — the edges of the tree. It is guaranteed that the given edges form a tree. It is guaranteed that the tree contains at least one red vertex and at least one blue vertex.
Output
Print a single integer — the number of nice edges in the given tree.
Examples
Input
5
2 0 0 1 2
1 2
2 3
2 4
2 5
Output
1
Input
5
1 0 0 0 2
1 2
2 3
3 4
4 5
Output
4
Input
3
1 1 2
2 3
1 3
Output
0
Note
Here is the tree from the first example:
<image>
The only nice edge is edge (2, 4). Removing it makes the tree fall apart into components \{4\} and \{1, 2, 3, 5\}. The first component only includes a red vertex and the second component includes blue vertices and uncolored vertices.
Here is the tree from the second example:
<image>
Every edge is nice in it.
Here is the tree from the third example:
<image>
Edge (1, 3) splits the into components \{1\} and \{3, 2\}, the latter one includes both red and blue vertex, thus the edge isn't nice. Edge (2, 3) splits the into components \{1, 3\} and \{2\}, the former one includes both red and blue vertex, thus the edge also isn't nice. So the answer is 0.
|
#include <bits/stdc++.h>
using namespace std;
void DEB(istream_iterator<string> it) {}
template <typename T, typename... Args>
void DEB(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << '\n';
DEB(++it, args...);
}
const int N = 3e5 + 5, mod = 1e9 + 7, inf = 1e9 + 7;
int f[N][3];
int n, res;
int a[N];
vector<int> adj[N];
bool ck[N];
void dfs1(int u, int e) {
if (a[u] == 1) {
f[u][1]++;
}
if (a[u] == 2) {
f[u][2]++;
}
for (auto v : adj[u]) {
if (v != e) {
dfs1(v, u);
f[u][1] += f[v][1];
f[u][2] += f[v][2];
}
}
}
void dfs2(int u, int e) {
if (e != -1) {
f[e][1] -= f[u][1];
f[e][2] -= f[u][2];
if (!f[u][1] && !f[e][2]) {
res++;
} else if (!f[u][2] && !f[e][1]) {
res++;
}
f[u][1] += f[e][1];
f[u][2] += f[e][2];
}
for (auto v : adj[u]) {
if (v != e) {
dfs2(v, u);
}
}
if (e != -1) {
f[u][1] -= f[e][1];
f[u][2] -= f[e][2];
f[e][1] += f[u][1];
f[e][2] += f[u][2];
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs1(1, -1);
dfs2(1, -1);
cout << res;
}
|
<image>
Input
The input contains a single integer a (0 ≤ a ≤ 15).
Output
Output a single integer.
Example
Input
3
Output
13
|
print([15,14,12,13,8,9,10,11,0,1,2,3,4,5,6,7][input()])
|
Tom loves vowels, and he likes long words with many vowels. His favorite words are vowelly words. We say a word of length k is vowelly if there are positive integers n and m such that n⋅ m = k and when the word is written by using n rows and m columns (the first row is filled first, then the second and so on, with each row filled from left to right), every vowel of the English alphabet appears at least once in every row and every column.
You are given an integer k and you must either print a vowelly word of length k or print -1 if no such word exists.
In this problem the vowels of the English alphabet are 'a', 'e', 'i', 'o' ,'u'.
Input
Input consists of a single line containing the integer k (1≤ k ≤ 10^4) — the required length.
Output
The output must consist of a single line, consisting of a vowelly word of length k consisting of lowercase English letters if it exists or -1 if it does not.
If there are multiple possible words, you may output any of them.
Examples
Input
7
Output
-1
Input
36
Output
agoeuioaeiruuimaeoieauoweouoiaouimae
Note
In the second example, the word "agoeuioaeiruuimaeoieauoweouoiaouimae" can be arranged into the following 6 × 6 grid:
<image>
It is easy to verify that every row and every column contain all the vowels.
|
N = int(input())
def make_vowels(N):
ans = ["aeiou", "eioua", "iouae", "ouaei", "uaeio"]
vowels = "aeiou"
m = 5
while m < N:
if N % m == 0 and N // m >= 5:
break
m += 1
else:
return print(-1)
n = N // m
for i in range(n):
if i <= 4:
ans[i] = ans[i]+(vowels[i]*(m-5))
else:
ans.append("aeiou"+"b"*(m-5))
ans = "".join(ans)
return print(ans)
make_vowels(N)
|
With your help, Heidi has prepared a plan of trap placement and defence. Yet suddenly, the Doctor popped out of the TARDIS and told her that he had spied on the Daleks' preparations, and there is more of them than ever. Desperate times require desperate measures, so Heidi is going to risk meeting with the Daleks and she will consider placing a trap along any Corridor.
This means she needs your help again in calculating E_{max}(c) – the largest e ≤ 10^9 such that if we changed the energy requirement of c to e, then the Daleks might use c in their invasion – but this time for all Time Corridors.
Input
First line: number n of destinations, number m of corridors (2 ≤ n ≤ 10^5, n - 1 ≤ m ≤ 10^6). The next m lines: destinations a, b and energy e (1 ≤ a, b ≤ n, a ≠ b, 0 ≤ e ≤ 10^9).
No pair \\{a, b\} will repeat. The graph is guaranteed to be connected. It is not guaranteed that all energy requirements e are distinct, or that the minimum spanning tree is unique.
Output
Output m lines, each containing one integer: E_{max}(c_i) for the i-th Corridor c_i from the input.
Example
Input
3 3
1 2 8
2 3 3
3 1 4
Output
4
8
8
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
template <typename T>
struct hash_map_t {
vector<T> v, val, nxt;
vector<int> head;
int mod, tot, lastv;
T lastans;
bool have_ans;
hash_map_t(int md = 0) {
head.clear();
v.clear();
val.clear();
nxt.clear();
tot = 0;
mod = md;
nxt.resize(1);
v.resize(1);
val.resize(1);
head.resize(mod);
have_ans = 0;
}
void clear() { *this = hash_map_t(mod); }
bool count(int x) {
int u = x % mod;
for (register int i = head[u]; i; i = nxt[i]) {
if (v[i] == x) {
have_ans = 1;
lastv = x;
lastans = val[i];
return 1;
}
}
return 0;
}
void ins(int x, int y) {
int u = x % mod;
nxt.push_back(head[u]);
head[u] = ++tot;
v.push_back(x);
val.push_back(y);
}
int qry(int x) {
if (have_ans && lastv == x) return lastans;
count(x);
return lastans;
}
};
const int N = 1e5 + 5;
struct ele {
int u, v, val, id, tag;
bool operator<(const ele A) const { return val < A.val; }
} a[N * 10];
struct edge_t {
int u, v, next, val, id;
} G[N << 1];
multiset<int> g[N];
multiset<int>::iterator it;
vector<int> del[N];
int ans[N * 10], f[N], head[N], maxn[N][20], fa[N][20], id[N], d[N], trueid[N];
int n, m, tot;
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
inline void addedge(int u, int v, int val, int id) {
G[++tot] = (edge_t){u, v, head[u], val, id}, head[u] = tot;
G[++tot] = (edge_t){v, u, head[v], val, id}, head[v] = tot;
}
void dfs1(int u, int f) {
for (register int i = 1; i <= 19; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
maxn[u][i] = max(maxn[u][i - 1], maxn[fa[u][i - 1]][i - 1]);
}
for (register int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (v == f) continue;
fa[v][0] = u;
maxn[v][0] = G[i].val;
id[v] = G[i].id;
d[v] = d[u] + 1;
dfs1(v, u);
}
}
int lca(int u, int v) {
if (d[u] < d[v]) swap(u, v);
for (register int i = 19; i >= 0; i--) {
if (d[fa[u][i]] >= d[v]) {
u = fa[u][i];
}
}
if (u == v) return u;
for (register int i = 19; i >= 0; i--) {
if (fa[u][i] != fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
}
}
return fa[u][0];
}
int query(int u, int v) {
int ans = 0;
if (d[u] < d[v]) swap(u, v);
for (register int i = 19; i >= 0; i--) {
if (d[fa[u][i]] >= d[v]) {
ans = max(ans, maxn[u][i]);
u = fa[u][i];
}
}
if (u == v) return ans;
for (register int i = 19; i >= 0; i--) {
if (fa[u][i] != fa[v][i]) {
ans = max(ans, max(maxn[u][i], maxn[v][i]));
u = fa[u][i];
v = fa[v][i];
}
}
return max(ans, max(maxn[u][0], maxn[v][0]));
}
void dfs2(int u, int f) {
trueid[u] = u;
for (register int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (v == f) continue;
dfs2(v, u);
if (g[trueid[v]].size() < g[trueid[u]].size()) {
for (it = g[trueid[v]].begin(); it != g[trueid[v]].end(); ++it)
g[trueid[u]].insert(*it);
g[trueid[v]].clear();
} else {
for (it = g[trueid[u]].begin(); it != g[trueid[u]].end(); ++it)
g[trueid[v]].insert(*it);
g[trueid[u]].clear();
trueid[u] = trueid[v];
}
}
if (u == 1) return;
for (register unsigned i = 0; i < del[u].size(); i++)
g[trueid[u]].erase(g[trueid[u]].find(del[u][i]));
if (g[trueid[u]].size() == 0)
ans[id[u]] = 1e9;
else
ans[id[u]] = *g[trueid[u]].begin();
}
int main() {
read(n);
read(m);
for (register int i = 1; i <= m; i++) {
read(a[i].u);
read(a[i].v);
read(a[i].val);
a[i].id = i;
}
sort(a + 1, a + m + 1);
for (register int i = 1; i <= n; i++) f[i] = i;
for (register int i = 1; i <= m; i++) {
int x = find(a[i].u), y = find(a[i].v);
if (x != y) {
f[x] = y;
a[i].tag = 1;
addedge(a[i].u, a[i].v, a[i].val, a[i].id);
}
}
d[1] = 1;
dfs1(1, 0);
for (register int i = 1; i <= m; i++) {
if (a[i].tag == 0) {
ans[a[i].id] = query(a[i].u, a[i].v);
int d = lca(a[i].u, a[i].v);
g[a[i].u].insert(a[i].val);
g[a[i].v].insert(a[i].val);
del[d].push_back(a[i].val);
del[d].push_back(a[i].val);
}
}
dfs2(1, 0);
for (register int i = 1; i <= m; i++) print(ans[i], '\n');
return 0;
}
|
The only difference between easy and hard versions is the length of the string.
You are given a string s and a string t, both consisting only of lowercase Latin letters. It is guaranteed that t can be obtained from s by removing some (possibly, zero) number of characters (not necessary contiguous) from s without changing order of remaining characters (in other words, it is guaranteed that t is a subsequence of s).
For example, the strings "test", "tst", "tt", "et" and "" are subsequences of the string "test". But the strings "tset", "se", "contest" are not subsequences of the string "test".
You want to remove some substring (contiguous subsequence) from s of maximum possible length such that after removing this substring t will remain a subsequence of s.
If you want to remove the substring s[l;r] then the string s will be transformed to s_1 s_2 ... s_{l-1} s_{r+1} s_{r+2} ... s_{|s|-1} s_{|s|} (where |s| is the length of s).
Your task is to find the maximum possible length of the substring you can remove so that t is still a subsequence of s.
Input
The first line of the input contains one string s consisting of at least 1 and at most 2 ⋅ 10^5 lowercase Latin letters.
The second line of the input contains one string t consisting of at least 1 and at most 2 ⋅ 10^5 lowercase Latin letters.
It is guaranteed that t is a subsequence of s.
Output
Print one integer — the maximum possible length of the substring you can remove so that t is still a subsequence of s.
Examples
Input
bbaba
bb
Output
3
Input
baaba
ab
Output
2
Input
abcde
abcde
Output
0
Input
asdfasdf
fasd
Output
3
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author keyur_jain
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskD2 solver = new TaskD2();
solver.solve(1, in, out);
out.close();
}
static class TaskD2 {
public void solve(int testNumber, InputReader in, OutputWriter out) {
String s = in.nextString();
String t = in.nextString();
int n = s.length(), m = t.length();
Integer[] prefixMatch = new Integer[n];
Integer[] suffixMatch = new Integer[n];
int j = 0;
for (int i = 0; i < n; i++) {
if (j < m && s.charAt(i) == t.charAt(j)) {
j += 1;
prefixMatch[i] = j;
} else {
prefixMatch[i] = (i != 0) ? prefixMatch[i - 1] : 0;
}
}
j = 0;
for (int i = n - 1; i >= 0; i--) {
if (j < m && s.charAt(i) == t.charAt(m - j - 1)) {
j += 1;
suffixMatch[i] = j;
} else {
suffixMatch[i] = (i != n - 1) ? suffixMatch[i + 1] : 0;
}
}
int answer = n - BinarySearch.LowerBound(prefixMatch, m) - 1;
for (int i = n - 1; i >= 0; i--) {
int have = suffixMatch[i];
int need = m - have;
int idx = BinarySearch.LowerBound(prefixMatch, need);
if (need == 0) idx = -1;
answer = Math.max(answer, i - idx - 1);
}
out.println(answer);
}
}
static class BinarySearch {
public static <T extends Comparable<T>> int LowerBound(T[] arr, T x) {
int lo = 0, hi = arr.length - 1;
while (lo < hi) {
int mid = (lo + hi) >> 1;
if (arr[mid].compareTo(x) < 0) {
lo = mid + 1;
} else {
hi = mid;
}
}
return (arr[lo].compareTo(x) < 0) ? arr.length : lo;
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public String nextString() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
if (Character.isValidCodePoint(c)) {
res.appendCodePoint(c);
}
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void close() {
writer.close();
}
public void println(int i) {
writer.println(i);
}
}
}
|
Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i ⋅ a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 ⩽ n ⩽ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 ≤ M_{ij} ≤ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 ≤ a_i ≤ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998
|
import java.util.Scanner;
//*1300
public class Multiplication_Table
{
static Scanner sc = new Scanner(System.in);
public static void main(String[] args)
{
solve();
}
protected static void solve()
{
int n = sc.nextInt();
long a[][] = new long[n][n];
for(int i = 0; i < n; i++)
{
for(int j = 0;j<n;j++)
{
a[i][j] = sc.nextLong();
}
}
long k= (long)Math.sqrt((a[0][1]*a[0][2])/a[1][2]);
System.out.print(k+" ");
for(int i = 1;i<n;i++)
System.out.print(a[0][i]/k+" ");
System.out.println();
}
}
|
Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i ≠ j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 ≤ n ≤ 2000) — the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 ≤ x_i ≤ 10^6) and y_i (1 ≤ y_i ≤ 10^6) — the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9) — the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 ≤ k_i ≤ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v — the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e — the number of connections to be made.
Finally, print e pairs of integers a and b (1 ≤ a, b ≤ n, a ≠ b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 ⋅ (3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 ⋅ (2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen.
|
#include <bits/stdc++.h>
using namespace std;
const int DIM = 2005;
pair<int, int> pts[DIM];
long long dp[DIM];
bool oki[DIM];
int cst1[DIM], cst2[DIM], fth[DIM];
long long dist(int a, int b) {
if (a > b) swap(a, b);
if (a == 0)
return cst1[b];
else
return (cst2[a] + cst2[b]) * 1LL *
(abs(pts[a].first - pts[b].first) +
abs(pts[a].second - pts[b].second));
}
int main(void) {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> pts[i].first >> pts[i].second;
for (int i = 1; i <= n; ++i) cin >> cst1[i];
for (int i = 1; i <= n; ++i) cin >> cst2[i];
for (int i = 1; i <= n; ++i) dp[i] = (1LL << 60);
for (int t = 0; t <= n; ++t) {
int nd;
long long cm = (1LL << 60);
for (int i = 0; i <= n; ++i)
if (cm > dp[i] and !oki[i]) cm = dp[i], nd = i;
oki[nd] = true;
for (int i = 0; i <= n; ++i)
if (!oki[i] and dp[i] > dist(i, nd)) dp[i] = dist(i, nd), fth[i] = nd;
}
vector<int> src;
vector<pair<int, int>> edg;
long long ans = 0;
for (int i = 1; i <= n; ++i) {
if (fth[i] == 0)
src.push_back(i);
else
edg.push_back(make_pair(fth[i], i));
ans += dp[i];
}
cout << ans << "\n";
cout << src.size() << "\n";
for (int x : src) cout << x << " ";
cout << "\n";
cout << edg.size() << "\n";
for (pair<int, int> pr : edg) cout << pr.first << " " << pr.second << "\n";
return 0;
}
|
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5.
|
#include <bits/stdc++.h>
using namespace std;
const int base = 100003;
const long long MM = 1ll * 1000000007 * 1000000007;
int n, p[1000005];
void Solve() {
cin >> n;
int l = 2e9;
int r = -1;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
p[x] = i;
}
for (int i = 1; i <= n; ++i) {
r = max(r, p[i]);
l = min(l, p[i]);
if (r - l + 1 == i)
cout << 1;
else
cout << 0;
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int test = 1;
cin >> test;
while (test--) Solve();
}
|
An infinitely long Line Chillland Collider (LCC) was built in Chillland. There are n pipes with coordinates x_i that are connected to LCC. When the experiment starts at time 0, i-th proton flies from the i-th pipe with speed v_i. It flies to the right with probability p_i and flies to the left with probability (1 - p_i). The duration of the experiment is determined as the time of the first collision of any two protons. In case there is no collision, the duration of the experiment is considered to be zero.
Find the expected value of the duration of the experiment.
<image>Illustration for the first example
Input
The first line of input contains one integer n — the number of pipes (1 ≤ n ≤ 10^5). Each of the following n lines contains three integers x_i, v_i, p_i — the coordinate of the i-th pipe, the speed of the i-th proton and the probability that the i-th proton flies to the right in percentage points (-10^9 ≤ x_i ≤ 10^9, 1 ≤ v ≤ 10^6, 0 ≤ p_i ≤ 100). It is guaranteed that all x_i are distinct and sorted in increasing order.
Output
It's possible to prove that the answer can always be represented as a fraction P/Q, where P is an integer and Q is a natural number not divisible by 998 244 353. In this case, print P ⋅ Q^{-1} modulo 998 244 353.
Examples
Input
2
1 1 100
3 1 0
Output
1
Input
3
7 10 0
9 4 86
14 5 100
Output
0
Input
4
6 4 50
11 25 50
13 16 50
15 8 50
Output
150902884
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int X = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') X = X * 10 + c - '0', c = getchar();
return X * w;
}
const int N = 100000 + 10;
const int mod = 998244353;
int qpow(int a, int b) {
int c = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) c = 1ll * c * a % mod;
return c;
}
int n, x[N], v[N], p[2][N], cnt = 0;
struct node {
int p, x, v, fl, fr;
} a[N << 1];
bool operator<(node a, node b) { return 1ll * a.x * b.v < 1ll * b.x * a.v; }
struct Matrix {
int s[2][2];
Matrix() { memset(s, 0, sizeof(s)); }
int* operator[](int i) { return s[i]; }
};
Matrix operator*(Matrix a, Matrix b) {
Matrix c;
for (int k = 0; k < 2; ++k)
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
c[i][j] = (c[i][j] + 1ll * a[i][k] * b[k][j]) % mod;
return c;
}
Matrix mulv[N << 2];
void pushup(int o) { mulv[o] = mulv[(o << 1)] * mulv[(o << 1 | 1)]; }
void build(int o, int l, int r) {
if (l == r) {
mulv[o][0][0] = mulv[o][1][0] = p[0][l];
mulv[o][0][1] = mulv[o][1][1] = p[1][l];
return;
}
int mid = (l + r) >> 1;
build((o << 1), l, mid), build((o << 1 | 1), mid + 1, r);
pushup(o);
}
void modify(int o, int l, int r, int p, int fl, int fr) {
if (l == r) {
mulv[o][fl][fr] = 0;
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
modify((o << 1), l, mid, p, fl, fr);
else
modify((o << 1 | 1), mid + 1, r, p, fl, fr);
pushup(o);
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
x[i] = read(), v[i] = read();
p[1][i] = 1ll * read() * qpow(100, mod - 2) % mod;
p[0][i] = (1 - p[1][i] + mod) % mod;
}
for (int i = 1; i < n; ++i) {
a[++cnt] = (node){i + 1, x[i + 1] - x[i], v[i] + v[i + 1], 1, 0};
if (v[i] < v[i + 1])
a[++cnt] = (node){i + 1, x[i + 1] - x[i], v[i + 1] - v[i], 0, 0};
if (v[i] > v[i + 1])
a[++cnt] = (node){i + 1, x[i + 1] - x[i], v[i] - v[i + 1], 1, 1};
}
sort(a + 1, a + cnt + 1);
build(1, 1, n);
int ans = 0;
for (int i = 1; i <= cnt; ++i) {
int P = (mulv[1][0][0] + mulv[1][0][1]) % mod;
modify(1, 1, n, a[i].p, a[i].fl, a[i].fr);
int Q = (mulv[1][0][0] + mulv[1][0][1]) % mod;
ans = (ans + 1ll * a[i].x * qpow(a[i].v, mod - 2) % mod * (P - Q + mod)) %
mod;
}
printf("%d\n", ans);
return 0;
}
|
Kuroni is very angry at the other setters for using him as a theme! As a punishment, he forced them to solve the following problem:
You have an array a consisting of n positive integers. An operation consists of choosing an element and either adding 1 to it or subtracting 1 from it, such that the element remains positive. We say the array is good if the greatest common divisor of all its elements is not 1. Find the minimum number of operations needed to make the array good.
Unable to match Kuroni's intellect, the setters failed to solve the problem. Help them escape from Kuroni's punishment!
Input
The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n. (1 ≤ a_i ≤ 10^{12}) — the elements of the array.
Output
Print a single integer — the minimum number of operations required to make the array good.
Examples
Input
3
6 2 4
Output
0
Input
5
9 8 7 3 1
Output
4
Note
In the first example, the first array is already good, since the greatest common divisor of all the elements is 2.
In the second example, we may apply the following operations:
1. Add 1 to the second element, making it equal to 9.
2. Subtract 1 from the third element, making it equal to 6.
3. Add 1 to the fifth element, making it equal to 2.
4. Add 1 to the fifth element again, making it equal to 3.
The greatest common divisor of all elements will then be equal to 3, so the array will be good. It can be shown that no sequence of three or less operations can make the array good.
|
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
class FKuroniAndThePunishment {
vector<long long> primes;
void sieve() {
int N = 1E6;
vector<bool> p(N, true);
for (long long i = 2; i < N; i++) {
if (p[i]) {
primes.push_back(i);
for (long long j = i * i; j < N; j += i) p[j] = false;
}
}
}
void primeFactor(long long n, set<long long>& s) {
for (long long Prime : primes) {
if (Prime * Prime > n) break;
if (n % Prime == 0) {
s.insert(Prime);
while (n % Prime == 0) n /= Prime;
}
}
if (n != 1) s.insert(n);
}
public:
void solve(std::istream& in, std::ostream& out) {
int n;
in >> n;
vector<long long> data(n);
for (long long& x : data) in >> x;
shuffle(data.begin(), data.end(), rng);
set<long long> coll;
for (int i = 0; i < 5 && i < n; i++) {
coll.insert(data[i]);
coll.insert(data[i] + 1);
if (data[i] > 3) coll.insert(data[i] - 1);
}
set<long long> check;
check.insert(2LL);
sieve();
for (long long x : coll) {
primeFactor(x, check);
}
long long ans = n;
for (long long x : check) {
long long k = 0LL;
for (long long num : data) {
if (num < x)
k += x - num;
else
k += min(num % x, x - num % x);
}
ans = min(k, ans);
}
out << ans << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
FKuroniAndThePunishment solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
A lot of people associate Logo programming language with turtle graphics. In this case the turtle moves along the straight line and accepts commands "T" ("turn around") and "F" ("move 1 unit forward").
You are given a list of commands that will be given to the turtle. You have to change exactly n commands from the list (one command can be changed several times). How far from the starting point can the turtle move after it follows all the commands of the modified list?
Input
The first line of input contains a string commands — the original list of commands. The string commands contains between 1 and 100 characters, inclusive, and contains only characters "T" and "F".
The second line contains an integer n (1 ≤ n ≤ 50) — the number of commands you have to change in the list.
Output
Output the maximum distance from the starting point to the ending point of the turtle's path. The ending point of the turtle's path is turtle's coordinate after it follows all the commands of the modified list.
Examples
Input
FT
1
Output
2
Input
FFFTFFF
2
Output
6
Note
In the first example the best option is to change the second command ("T") to "F" — this way the turtle will cover a distance of 2 units.
In the second example you have to change two commands. One of the ways to cover maximal distance of 6 units is to change the fourth command and first or last one.
|
import java.io.Closeable;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.AbstractList;
import java.io.Writer;
import java.util.Collection;
import java.util.List;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.StringTokenizer;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author Jacob Jiang
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
QuickScanner in = new QuickScanner(inputStream);
ExtendedPrintWriter out = new ExtendedPrintWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
}
class TaskC {
public static final int INF = Integer.MAX_VALUE / 20;
public void solve(int testNumber, QuickScanner in, ExtendedPrintWriter out) {
char[] commands = (" " + in.next()).toCharArray();
int n = commands.length - 1;
int toChange = in.nextInt();
int[][][] minPosition = new int[n + 1][toChange + 1][2];
int[][][] maxPosition = new int[n + 1][toChange + 1][2];
ArrayUtils.fill(minPosition, INF);
ArrayUtils.fill(maxPosition, -INF);
Arrays.fill(minPosition[0][0], 0);
Arrays.fill(maxPosition[0][0], 0);
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= toChange; j++) {
for (int k = 0; k < 2; k++) {
//not change
if (commands[i] == 'T') {
minPosition[i][j][k] = Math.min(minPosition[i][j][k], minPosition[i - 1][j][1 - k]);
maxPosition[i][j][k] = Math.max(maxPosition[i][j][k], maxPosition[i - 1][j][1 - k]);
} else {
minPosition[i][j][k] = Math.min(minPosition[i][j][k], minPosition[i - 1][j][k] + toward(k));
maxPosition[i][j][k] = Math.max(maxPosition[i][j][k], maxPosition[i - 1][j][k] + toward(k));
}
//change
if (j > 0) {
if (commands[i] == 'T') {
minPosition[i][j][k] = Math.min(minPosition[i][j][k], minPosition[i - 1][j - 1][k] + toward(k));
maxPosition[i][j][k] = Math.max(maxPosition[i][j][k], maxPosition[i - 1][j - 1][k] + toward(k));
} else {
minPosition[i][j][k] = Math.min(minPosition[i][j][k], minPosition[i - 1][j - 1][1 - k]);
maxPosition[i][j][k] = Math.max(maxPosition[i][j][k], maxPosition[i - 1][j - 1][1 - k]);
}
}
}
}
}
int answer = 0;
for (int j = toChange % 2; j <= toChange; j += 2) {
for (int k = 0; k < 2; k++) {
answer = Math.max(answer, -minPosition[n][j][k]);
answer = Math.max(answer, maxPosition[n][j][k]);
}
}
out.println(answer);
}
private int toward(int x) {
return x == 0 ? 1 : -1;
}
}
class QuickScanner implements Iterator<String>, Closeable {
BufferedReader reader;
StringTokenizer tokenizer;
boolean endOfFile = false;
public QuickScanner(InputStream inputStream) {
reader = new BufferedReader(new InputStreamReader(inputStream));
tokenizer = null;
}
public boolean hasNext() {
if (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
checkNext();
} catch (NoSuchElementException ignored) {
}
}
return !endOfFile;
}
private void checkNext() {
if (endOfFile) {
throw new NoSuchElementException();
}
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (Exception e) {
endOfFile = true;
throw new NoSuchElementException();
}
}
public String next() {
checkNext();
return tokenizer.nextToken();
}
public void remove() {
throw new UnsupportedOperationException();
}
public int nextInt() {
return Integer.parseInt(next());
}
public void close() {
try {
reader.close();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
class ExtendedPrintWriter extends PrintWriter {
public ExtendedPrintWriter(Writer out) {
super(out);
}
public ExtendedPrintWriter(OutputStream out) {
super(out);
}
}
class ArrayUtils {
private ArrayUtils() {
}
public static void fill(int[][] array, int val) {
for (int[] subArray : array) {
Arrays.fill(subArray, val);
}
}
public static void fill(int[][][] array, int val) {
for (int[][] subArray : array) {
ArrayUtils.fill(subArray, val);
}
}
}
|
You are given a sequence of positive integers a1, a2, ..., an. Find all such indices i, that the i-th element equals the arithmetic mean of all other elements (that is all elements except for this one).
Input
The first line contains the integer n (2 ≤ n ≤ 2·105). The second line contains elements of the sequence a1, a2, ..., an (1 ≤ ai ≤ 1000). All the elements are positive integers.
Output
Print on the first line the number of the sought indices. Print on the second line the sought indices in the increasing order. All indices are integers from 1 to n.
If the sought elements do not exist, then the first output line should contain number 0. In this case you may either not print the second line or print an empty line.
Examples
Input
5
1 2 3 4 5
Output
1
3
Input
4
50 50 50 50
Output
4
1 2 3 4
|
import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;
public class T1{
public T1(){
Scanner s = new Scanner(System.in);
int n = s.nextInt();
int k = 0;
long sum = 0;
int arr[] = new int[n];
int ans[] = new int[n];
for(int i = 0; i < n; i++){
arr[i] = s.nextInt();
sum += arr[i];
}
for(int i = 0; i < n; i++){
double res = 1.0 * (sum - arr[i]) / (n - 1);
if(res == arr[i]){
ans[k] = i + 1;
k++;
}
}
System.out.println(k);
for(int i = 0; i < k; i++)
System.out.print(ans[i] + " ");
}
public static void main(String args[]){
T1 t1 = new T1();
}
}
|
Let's consider all integers in the range from 1 to n (inclusive).
Among all pairs of distinct integers in this range, find the maximum possible greatest common divisor of integers in pair. Formally, find the maximum value of gcd(a, b), where 1 ≤ a < b ≤ n.
The greatest common divisor, gcd(a, b), of two positive integers a and b is the biggest integer that is a divisor of both a and b.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The only line of each test case contains a single integer n (2 ≤ n ≤ 10^6).
Output
For each test case, output the maximum value of gcd(a, b) among all 1 ≤ a < b ≤ n.
Example
Input
2
3
5
Output
1
2
Note
In the first test case, gcd(1, 2) = gcd(2, 3) = gcd(1, 3) = 1.
In the second test case, 2 is the maximum possible value, corresponding to gcd(2, 4).
|
n = int(input())
for i in range(n):
print(int(input())//2)
|
Omkar is standing at the foot of Celeste mountain. The summit is n meters away from him, and he can see all of the mountains up to the summit, so for all 1 ≤ j ≤ n he knows that the height of the mountain at the point j meters away from himself is h_j meters. It turns out that for all j satisfying 1 ≤ j ≤ n - 1, h_j < h_{j + 1} (meaning that heights are strictly increasing).
Suddenly, a landslide occurs! While the landslide is occurring, the following occurs: every minute, if h_j + 2 ≤ h_{j + 1}, then one square meter of dirt will slide from position j + 1 to position j, so that h_{j + 1} is decreased by 1 and h_j is increased by 1. These changes occur simultaneously, so for example, if h_j + 2 ≤ h_{j + 1} and h_{j + 1} + 2 ≤ h_{j + 2} for some j, then h_j will be increased by 1, h_{j + 2} will be decreased by 1, and h_{j + 1} will be both increased and decreased by 1, meaning that in effect h_{j + 1} is unchanged during that minute.
The landslide ends when there is no j such that h_j + 2 ≤ h_{j + 1}. Help Omkar figure out what the values of h_1, ..., h_n will be after the landslide ends. It can be proven that under the given constraints, the landslide will always end in finitely many minutes.
Note that because of the large amount of input, it is recommended that your code uses fast IO.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6).
The second line contains n integers h_1, h_2, ..., h_n satisfying 0 ≤ h_1 < h_2 < ... < h_n ≤ 10^{12} — the heights.
Output
Output n integers, where the j-th integer is the value of h_j after the landslide has stopped.
Example
Input
4
2 6 7 8
Output
5 5 6 7
Note
Initially, the mountain has heights 2, 6, 7, 8.
In the first minute, we have 2 + 2 ≤ 6, so 2 increases to 3 and 6 decreases to 5, leaving 3, 5, 7, 8.
In the second minute, we have 3 + 2 ≤ 5 and 5 + 2 ≤ 7, so 3 increases to 4, 5 is unchanged, and 7 decreases to 6, leaving 4, 5, 6, 8.
In the third minute, we have 6 + 2 ≤ 8, so 6 increases to 7 and 8 decreases to 7, leaving 4, 5, 7, 7.
In the fourth minute, we have 5 + 2 ≤ 7, so 5 increases to 6 and 7 decreases to 6, leaving 4, 6, 6, 7.
In the fifth minute, we have 4 + 2 ≤ 6, so 4 increases to 5 and 6 decreases to 5, leaving 5, 5, 6, 7.
In the sixth minute, nothing else can change so the landslide stops and our answer is 5, 5, 6, 7.
|
import java.io.*;
import java.util.*;
public class Main{
static void bruteForce(long[]in,int n) {
while(true) {
boolean modified=false;
long[]newin=in.clone();
for(int i=0;i<n-1;i++) {
if(in[i]+2<=in[i+1]) {
newin[i]++;
newin[i+1]--;
modified=true;
}
}
in=newin;
if(!modified)break;
}
System.out.println(Arrays.toString(in));
}
static void main() throws Exception{
int n=sc.nextInt();
long[]in=sc.longArr(n);
long sum=0;
boolean no=true;
for(int i=0;i<n;i++) {
sum+=in[i];
if(i<n-1) {
if(in[i]+2<=in[i+1]) {
no=false;
}
}
}
if(no) {
for(int i=0;i<n;i++) {
pw.print(in[i]+" ");
}
pw.println();
return;
}
long[]ans=new long[n];
Arrays.fill(ans, sum/n);
int delta=1;
int left=(n-1)/2-1,right=(n-1)/2+1;
while(left>=0 || right<n) {
if(left>=0)
ans[left]-=delta;
if(right<n)
ans[right]+=delta;
left--;
right++;
delta++;
}
long rem=sum;
for(int i=0;i<n;i++) {
rem-=ans[i];
}
if(rem<0) {
rem+=n;
for(int i=0;i<n;i++) {
ans[i]--;
}
}
for(int i=0;i<n && rem>0;i++) {
ans[i]++;
rem--;
}
for(int i=0;i<n;i++) {
pw.print(ans[i]+" ");
}
pw.println();
}
public static void main(String[] args) throws Exception{
sc=new MScanner(System.in);
pw = new PrintWriter(System.out);
int tc=1;
// tc=sc.nextInt();
while(tc-->0)
main();
pw.flush();
}
static PrintWriter pw;
static MScanner sc;
static class MScanner {
StringTokenizer st;
BufferedReader br;
public MScanner(InputStream system) {
br = new BufferedReader(new InputStreamReader(system));
}
public MScanner(String file) throws Exception {
br = new BufferedReader(new FileReader(file));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int[] intArr(int n) throws IOException {
int[]in=new int[n];for(int i=0;i<n;i++)in[i]=nextInt();
return in;
}
public long[] longArr(int n) throws IOException {
long[]in=new long[n];for(int i=0;i<n;i++)in[i]=nextLong();
return in;
}
public int[] intSortedArr(int n) throws IOException {
int[]in=new int[n];for(int i=0;i<n;i++)in[i]=nextInt();
shuffle(in);
Arrays.sort(in);
return in;
}
public long[] longSortedArr(int n) throws IOException {
long[]in=new long[n];for(int i=0;i<n;i++)in[i]=nextLong();
shuffle(in);
Arrays.sort(in);
return in;
}
public Integer[] IntegerArr(int n) throws IOException {
Integer[]in=new Integer[n];for(int i=0;i<n;i++)in[i]=nextInt();
return in;
}
public Long[] LongArr(int n) throws IOException {
Long[]in=new Long[n];for(int i=0;i<n;i++)in[i]=nextLong();
return in;
}
public String nextLine() throws IOException {
return br.readLine();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public char nextChar() throws IOException {
return next().charAt(0);
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public boolean ready() throws IOException {
return br.ready();
}
public void waitForInput() throws InterruptedException {
Thread.sleep(3000);
}
}
static void shuffle(int[]in) {
for(int i=0;i<in.length;i++) {
int idx=(int)(Math.random()*in.length);
int tmp=in[i];
in[i]=in[idx];
in[idx]=tmp;
}
}
static void shuffle(long[]in) {
for(int i=0;i<in.length;i++) {
int idx=(int)(Math.random()*in.length);
long tmp=in[i];
in[i]=in[idx];
in[idx]=tmp;
}
}
}
|
RedDreamer has an array a consisting of n non-negative integers, and an unlucky integer T.
Let's denote the misfortune of array b having length m as f(b) — the number of pairs of integers (i, j) such that 1 ≤ i < j ≤ m and b_i + b_j = T. RedDreamer has to paint each element of a into one of two colors, white and black (for each element, the color is chosen independently), and then create two arrays c and d so that all white elements belong to c, and all black elements belong to d (it is possible that one of these two arrays becomes empty). RedDreamer wants to paint the elements in such a way that f(c) + f(d) is minimum possible.
For example:
* if n = 6, T = 7 and a = [1, 2, 3, 4, 5, 6], it is possible to paint the 1-st, the 4-th and the 5-th elements white, and all other elements black. So c = [1, 4, 5], d = [2, 3, 6], and f(c) + f(d) = 0 + 0 = 0;
* if n = 3, T = 6 and a = [3, 3, 3], it is possible to paint the 1-st element white, and all other elements black. So c = [3], d = [3, 3], and f(c) + f(d) = 0 + 1 = 1.
Help RedDreamer to paint the array optimally!
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains two integers n and T (1 ≤ n ≤ 10^5, 0 ≤ T ≤ 10^9) — the number of elements in the array and the unlucky integer, respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 10^9) — the elements of the array.
The sum of n over all test cases does not exceed 10^5.
Output
For each test case print n integers: p_1, p_2, ..., p_n (each p_i is either 0 or 1) denoting the colors. If p_i is 0, then a_i is white and belongs to the array c, otherwise it is black and belongs to the array d.
If there are multiple answers that minimize the value of f(c) + f(d), print any of them.
Example
Input
2
6 7
1 2 3 4 5 6
3 6
3 3 3
Output
1 0 0 1 1 0
1 0 0
|
for I in range(int(input())):
n,t = map(int,input().split())
a = list(map(int,input().split()))
d = []
if t % 2 != 0:
for i in range(n):
if a[i] <= t // 2:
d.append(1)
else:
d.append(0)
else:
p = 0
for i in range(n):
if a[i] < t//2:
d.append(1)
elif a[i] > t//2:
d.append(0)
else:
d.append(p)
p = (p + 1) % 2
print(*d)
|
You are a mayor of Berlyatov. There are n districts and m two-way roads between them. The i-th road connects districts x_i and y_i. The cost of travelling along this road is w_i. There is some path between each pair of districts, so the city is connected.
There are k delivery routes in Berlyatov. The i-th route is going from the district a_i to the district b_i. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district a_i to the district b_i to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with 0).
Let d(x, y) be the cheapest cost of travel between districts x and y.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with 0. In other words, you have to find the minimum possible value of ∑_{i = 1}^{k} d(a_i, b_i) after applying the operation described above optimally.
Input
The first line of the input contains three integers n, m and k (2 ≤ n ≤ 1000; n - 1 ≤ m ≤ min(1000, (n(n-1))/(2)); 1 ≤ k ≤ 1000) — the number of districts, the number of roads and the number of courier routes.
The next m lines describe roads. The i-th road is given as three integers x_i, y_i and w_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i; 1 ≤ w_i ≤ 1000), where x_i and y_i are districts the i-th road connects and w_i is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next k lines describe courier routes. The i-th route is given as two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the districts of the i-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
Output
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value ∑_{i=1}^{k} d(a_i, b_i), where d(x, y) is the cheapest cost of travel between districts x and y) if you can make some (at most one) road cost zero.
Examples
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
Note
The picture corresponding to the first example:
<image>
There, you can choose either the road (2, 4) or the road (4, 6). Both options lead to the total cost 22.
The picture corresponding to the second example:
<image>
There, you can choose the road (3, 4). This leads to the total cost 13.
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1100, M = 1e5 + 10;
int g[N], nxt[M], v[M], w[M], ed;
void add(int x, int y, int z) {
v[++ed] = y, nxt[ed] = g[x], g[x] = ed, w[ed] = z;
}
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
void dj(int s, int n, long long *d) {
int x;
for (int i = 1; i <= n; i++) d[i] = inf;
q.push({d[s] = 0, s});
while (!q.empty()) {
pair<int, int> t = q.top();
q.pop();
if (d[x = t.second] < t.first) continue;
for (int i = g[x]; i; i = nxt[i])
if (d[x] + w[i] < d[v[i]]) {
q.push({d[v[i]] = d[x] + w[i], v[i]});
}
}
}
long long d[N][N];
pair<int, int> a[N], b[N];
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1, x, y, z; i <= m; i++) {
cin >> x >> y >> z;
b[i].first = x, b[i].second = y;
add(x, y, z), add(y, x, z);
}
for (int i = 1; i <= k; i++) cin >> a[i].first >> a[i].second;
for (int i = 1; i <= n; i++) dj(i, n, d[i]);
long long ans = inf;
for (int i = 1; i <= m; i++) {
long long sum = 0;
int x = b[i].first, y = b[i].second;
for (int j = 1; j <= k; j++) {
int s = a[j].first, t = a[j].second;
long long d1 = d[s][t];
long long d2 = d[s][x] + d[y][t];
long long d3 = d[s][y] + d[x][t];
sum += min(d1, min(d2, d3));
}
ans = min(ans, sum);
}
cout << ans << '\n';
return 0;
}
|
You are given a tree with n vertices numbered 1, …, n. A tree is a connected simple graph without cycles.
Let dist(u, v) be the number of edges in the unique simple path connecting vertices u and v.
Let diam(l, r) = max dist(u, v) over all pairs u, v such that l ≤ u, v ≤ r.
Compute ∑_{1 ≤ l ≤ r ≤ n} diam(l, r).
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of vertices in the tree.
The next n - 1 lines describe the tree edges. Each of these lines contains two integers u, v (1 ≤ u, v ≤ n) — endpoint indices of the respective tree edge. It is guaranteed that the edge list indeed describes a tree.
Output
Print a single integer — ∑_{1 ≤ l ≤ r ≤ n} diam(l, r).
Examples
Input
4
1 2
2 4
3 2
Output
10
Input
10
1 8
2 9
5 6
4 8
4 2
7 9
3 6
10 4
3 9
Output
224
|
#include<bits/stdc++.h>
#define rd(x) x=read()
#define N 200005
#define int long long
using namespace std;
int n,k;
vector<int>e[N];
int vis[N],mn,rt;
int s[N],dep[N],p[N][21],faa[N],f[21][N];
int b[N],c[N],w[N],g[N],suf[N];
inline int read()
{
int x=0,f=1;char ch=getchar();
while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();if(ch==-1)return 0;}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
inline void addEdge(int u,int v){e[u].push_back(v),e[v].push_back(u);}
void dfs(int u,int fa){s[u]=1;for(int v:e[u])if(v!=fa&&!vis[v])dfs(v,u),s[u]+=s[v];}
void dfss(int u,int fa){dep[u]=dep[fa]+1,p[u][0]=fa;for(int i=1;(1<<i)<=dep[u];i++)p[u][i]=p[p[u][i-1]][i-1];for(int v:e[u])if(v!=fa)dfss(v,u);}
void dfsss(int u,int fa,int r){for(int v:e[u])if(v!=fa&&!vis[v])f[r][v]=f[r][u]+1,dfsss(v,u,r);}
void getroot(int u,int fa)
{
int ans=k-s[u];
for(int v:e[u])if(v!=fa&&!vis[v])getroot(v,u),ans=max(ans,s[v]);
if(ans<mn)mn=ans,rt=u;
}
void dfssss(int u,int fa){dfs(u,0),mn=k=s[u],getroot(u,0);vis[u=rt]=1,g[u]=g[faa[u]=fa]+1,dfsss(u,0,g[u]);for(int v:e[u])if(!vis[v])dfssss(v,u);}
int lca(int u,int v)
{
if(dep[u]>dep[v])swap(u,v);for(int i=20;i>=0;i--)if(dep[u]<=dep[v]-(1<<i))v=p[v][i];
if(u==v)return u;for(int i=20;i>=0;i--)if(p[u][i]!=p[v][i])u=p[u][i],v=p[v][i];return p[u][0];
}
inline int dis(int u,int v){return dep[u]+dep[v]-2*dep[lca(u,v)];}
inline void ins(int u,int x){for(int i=u,j=g[u];i;i=faa[i],j--){if(j>1)w[i]+=x*f[j-1][u];b[i]+=x*f[j][u],c[i]+=x;}}
inline int query(int u){int ans=b[u];for(int i=u,j=faa[u],l=g[u]-1;j;i=j,j=faa[j],l--)ans+=(c[j]-c[i])*f[l][u]+b[j]-w[i];return ans;}
int getanc(int u,int d){for(int i=20;i>=0;i--)if(d>=(1<<i))d-=(1<<i),u=p[u][i];return u;}
int getcenter(int u,int v,int d){int t=lca(u,v);if(dep[u]-dep[t]>=d)return getanc(u,d);return getanc(v,dep[v]-dep[t]-(d-=dep[u]-dep[t]));}
struct C{int u,r;}a[N];C add(C x,C y){int d=dis(x.u,y.u);if(y.r+d<=x.r)return x;if(x.r+d<=y.r)return y;return C{getcenter(x.u,y.u,(x.r+d+y.r)/2-x.r),(x.r+d+y.r)/2};}
inline bool check1(int i,int j){return a[i].r+dis(a[i].u,a[j].u)<=a[j].r;}inline bool check2(int i,int j){return a[i].r+dis(a[i].u,a[j].u)<a[j].r;}
int ans;
void solve(int l,int r)
{
if(l==r)return ;int mid=(l+r)>>1;
a[mid]=C{mid,0};for(int i=mid-1;i>=l;i--)a[i]=add(a[i+1],C{i,0});
a[mid+1]=C{mid+1,0};for(int i=mid+2;i<=r;i++)a[i]=add(a[i-1],C{i,0});
int L=mid,R=mid+1;suf[r+1]=0;for(int i=r;i>=mid;i--)suf[i]=suf[i+1]+a[i].r;
for(int i=mid;i>=l;i--)
{
while(R<=r&&!check1(i,R))ins(a[R++].u,1);
while(L<r&&check2(L+1,i))ins(a[++L].u,-1);
ans+=suf[R]+1ll*(L-mid)*a[i].r+(suf[L+1]-suf[R]+1ll*(R-L-1)*a[i].r+query(a[i].u))/2;
}
while(L+1<R)ins(a[++L].u,-1);solve(l,mid),solve(mid+1,r);
}
signed main()
{
rd(n);
for(int i=1,u,v;i<n;i++)rd(u),rd(v),addEdge(u,i+n),addEdge(i+n,v);
dfss(1,0),dfssss(1,0),solve(1,n),cout<<ans<<endl;
return 0;
}
|
Kilani and Abd are neighbors for 3000 years, but then the day came and Kilani decided to move to another house. As a farewell gift, Kilani is going to challenge Abd with a problem written by their other neighbor with the same name Abd.
<image>
The problem is:
You are given a connected tree rooted at node 1.
You should assign a character a or b to every node in the tree so that the total number of a's is equal to x and the total number of b's is equal to n - x.
Let's define a string for each node v of the tree as follows:
* if v is root then the string is just one character assigned to v:
* otherwise, let's take a string defined for the v's parent p_v and add to the end of it a character assigned to v.
You should assign every node a character in a way that minimizes the number of distinct strings among the strings of all nodes.
Input
The first line contains two integers n and x (1 ≤ n ≤ 10^5; 0 ≤ x ≤ n) — the number of vertices in the tree the number of a's.
The second line contains n - 1 integers p_2, p_3, ..., p_{n} (1 ≤ p_i ≤ n; p_i ≠ i), where p_i is the parent of node i.
It is guaranteed that the input describes a connected tree.
Output
In the first line, print the minimum possible total number of distinct strings.
In the second line, print n characters, where all characters are either a or b and the i-th character is the character assigned to the i-th node.
Make sure that the total number of a's is equal to x and the total number of b's is equal to n - x.
If there is more than one answer you can print any of them.
Example
Input
9 3
1 2 2 4 4 4 3 1
Output
4
aabbbbbba
Note
The tree from the sample is shown below:
<image>
The tree after assigning characters to every node (according to the output) is the following:
<image>
Strings for all nodes are the following:
* string of node 1 is: a
* string of node 2 is: aa
* string of node 3 is: aab
* string of node 4 is: aab
* string of node 5 is: aabb
* string of node 6 is: aabb
* string of node 7 is: aabb
* string of node 8 is: aabb
* string of node 9 is: aa
The set of unique strings is \{a, aa, aab, aabb\}, so the number of distinct strings is 4.
|
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<vector>
#include<map>
#include<queue>
#include<array>
#include<queue>
#include<set>
using namespace std;
#define imax(a,b) (((a)>(b))?(a):(b))
#define imin(a,b) (((a)<(b))?(a):(b))
#define mp make_pair
typedef long long ll;
const int N = 1e5 + 10;
const int inf = 1e9 + 7;
int n, k, td, tg;
int h[N], ne[N], to[N], tt;
int fa[N], sz[N], cs[N];
int dp[500][N];
vector<int> cur[N];
struct dop
{
int val, s;
} g[N];
vector<pair<int, int>> V;
char ans[N];
void read(int& x)
{
x = 0; char ch = getchar(); bool f = 0;
while (!(ch >= '0' && ch <= '9')) f |= (ch == '-'), ch = getchar();
while ((ch >= '0' && ch <= '9')) x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
if (f) x = -x;
}
/*ll Mul(ll x, ll y, ll mods)
{
ll s = 0;
for (; y; y >>= 1, x = (x << 1) % mods)
if (y & 1) s = (s + x) % mods;
return s;
}
ll Pow(ll x, ll y, ll mods)
{
ll s = 1;
for (; y; y >>= 1, x = Mul(x, x, mods))
if (y & 1) s = Mul(s, x, mods);
return s;
}
ll gcd(ll x, ll y) { return (y ? gcd(y, x % y) : x); }
*/
void addedge(int a, int b)
{
to[++tt] = b; ne[tt] = h[a]; h[a] = tt;
}
int dfs(int x, int d)
{
td = imax(td, d); fa[d]++;
cur[d].push_back(x); sz[x] = 1;
for (int p = h[x];p;p = ne[p]) sz[x] += dfs(to[p], d + 1);
return sz[x];
}
bool cmp(int a, int b) { return sz[a] < sz[b]; }
int main()
{
read(n); read(k); tt = 1;
pair<int, char> A(k, 'a'), B(n - k, 'b');
td = 0; tg = 0;
for (int i = 2;i <= n;++i) read(fa[i]), addedge(fa[i], i);
for (int i = 0;i <= n;++i) fa[i] = 0;
dfs(1, 0);
for (int i = 0;i <= td;++i) cs[fa[i]]++;
for (int i = 1;i <= n;++i)
if (cs[i]) V.push_back(mp(i, cs[i]));
dp[(int)V.size()][0] = 1;
int val = 0, frq = 0, * last = cs;
for (int i = (int)V.size() - 1;i >= 0;--i)
{
val = V[i].first; frq = V[i].second;
for (int j = 0;j <= val;++j) last[j] = -1;
for (int j = 0;j <= A.first;++j)
{
if (dp[i + 1][j]) last[j % val] = j;
if (last[j % val] == -1 || ((j - last[j % val]) / val) > frq) dp[i][j] = 0;
else dp[i][j] = 1;
}
}
if (dp[0][A.first])
{
printf("%d\n", td + 1);
for (int i = 0;i <= n;++i) cs[i] = 0;
int Vs = V.size(), j = A.first;
for (int i = 0;i < Vs;++i)
{
while (!dp[i + 1][j])
{
j -= V[i].first;
cs[V[i].first]++;
}
}
for (int i = 0;i <= td;++i)
if(cs[fa[i]])
{
cs[fa[i]]--;
for (j = cur[i].size() - 1;j >= 0;--j) ans[cur[i][j] - 1] = A.second;
}
else for (j = cur[i].size() - 1;j >= 0;--j) ans[cur[i][j] - 1] = B.second;
ans[n] = '\0';
puts(ans);
}
else
{
printf("%d\n", td + 2);
for (int i = 0;i <= td;++i)
{
sort(cur[i].begin(), cur[i].end(), cmp);
if (A.first < B.first) swap(A, B);
while ((int)cur[i].size() > 0 && A.first > 0)
{
ans[cur[i].back() - 1] = A.second;
A.first--; cur[i].pop_back();
}
while ((int)cur[i].size() > 0 && B.first > 0)
{
ans[cur[i].back() - 1] = B.second;
B.first--; cur[i].pop_back();
}
}
ans[n] = '\0';puts(ans);
}
return 0;
}
|
Sayaka Saeki is a member of the student council, which has n other members (excluding Sayaka). The i-th member has a height of a_i millimeters.
It's the end of the school year and Sayaka wants to take a picture of all other members of the student council. Being the hard-working and perfectionist girl as she is, she wants to arrange all the members in a line such that the amount of photogenic consecutive pairs of members is as large as possible.
A pair of two consecutive members u and v on a line is considered photogenic if their average height is an integer, i.e. (a_u + a_v)/(2) is an integer.
Help Sayaka arrange the other members to maximize the number of photogenic consecutive pairs.
Input
The first line contains a single integer t (1≤ t≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 2000) — the number of other council members.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5) — the heights of each of the other members in millimeters.
It is guaranteed that the sum of n over all test cases does not exceed 2000.
Output
For each test case, output on one line n integers representing the heights of the other members in the order, which gives the largest number of photogenic consecutive pairs. If there are multiple such orders, output any of them.
Example
Input
4
3
1 1 2
3
1 1 1
8
10 9 13 15 3 16 9 13
2
18 9
Output
1 1 2
1 1 1
13 9 13 15 3 9 16 10
9 18
Note
In the first test case, there is one photogenic pair: (1, 1) is photogenic, as (1+1)/(2)=1 is integer, while (1, 2) isn't, as (1+2)/(2)=1.5 isn't integer.
In the second test case, both pairs are photogenic.
|
import java.io.*;
import java.util.*;
public class Main{
public static void main(String[] args) throws Exception{
sc=new MScanner(System.in);
pw = new PrintWriter(System.out);
int tc=sc.nextInt();
for(int j=1;j<=tc;j++) {
int l=sc.nextInt();
List<Integer> even=new ArrayList<>();
List<Integer> odd=new ArrayList<>();
while(l-- >0)
{
int num=sc.nextInt();
if(num%2==0)
even.add(num);
else
odd.add(num);
}
odd.addAll(even);
for(int i=0;i<odd.size();i++)
pw.print(odd.get(i)+" ");
pw.println();
}
pw.flush();
}
static PrintWriter pw;
static MScanner sc;
static class MScanner {
StringTokenizer st;
BufferedReader br;
public MScanner(InputStream system) {
br = new BufferedReader(new InputStreamReader(system));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int[] intArr(int n) throws IOException {
int[]in=new int[n];for(int i=0;i<n;i++)in[i]=nextInt();
return in;
}
public long[] longArr(int n) throws IOException {
long[]in=new long[n];for(int i=0;i<n;i++)in[i]=nextLong();
return in;
}
public Integer[] IntegerArr(int n) throws IOException {
Integer[]in=new Integer[n];for(int i=0;i<n;i++)in[i]=nextInt();
return in;
}
public Long[] LongArr(int n) throws IOException {
Long[]in=new Long[n];for(int i=0;i<n;i++)in[i]=nextLong();
return in;
}
public String nextLine() throws IOException {
return br.readLine();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public char nextChar() throws IOException {
return next().charAt(0);
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
}
}
|
Four players participate in the playoff tournament. The tournament is held according to the following scheme: the first player will play with the second, and the third player with the fourth, then the winners of the pairs will play in the finals of the tournament.
It is known that in a match between two players, the one whose skill is greater will win. The skill of the i-th player is equal to s_i and all skill levels are pairwise different (i. e. there are no two identical values in the array s).
The tournament is called fair if the two players with the highest skills meet in the finals.
Determine whether the given tournament is fair.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
A single line of test case contains four integers s_1, s_2, s_3, s_4 (1 ≤ s_i ≤ 100) — skill of the players. It is guaranteed that all the numbers in the array are different.
Output
For each testcase, output YES if the tournament is fair, or NO otherwise.
Example
Input
4
3 7 9 5
4 5 6 9
5 3 8 1
6 5 3 2
Output
YES
NO
YES
NO
Note
Consider the example:
1. in the first test case, players 2 and 3 with skills 7 and 9 advance to the finals;
2. in the second test case, players 2 and 4 with skills 5 and 9 advance to the finals. The player with skill 6 does not advance, but the player with skill 5 advances to the finals, so the tournament is not fair;
3. in the third test case, players 1 and 3 with skills 5 and 8 advance to the finals;
4. in the fourth test case, players 1 and 3 with skills 6 and 3 advance to the finals. The player with skill 5 does not advance, but the player with skill 3 advances to the finals, so the tournament is not fair.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;
public class Solve {
static int mod = 1000000000 + 7;
static long INF = 1000_000_000_000_000L + 100;
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner();
PrintWriter pw = new PrintWriter(System.out);
int t = sc.nextInt();
while (t-- > 0) {
int a[] = new int[4];
int s1 = sc.nextInt();
int s2 = sc.nextInt();
int s3 = sc.nextInt();
int s4 = sc.nextInt();
a[0] = s1;
a[1] = s2;
a[2] = s3;
a[3] = s4;
Arrays.sort(a);
int x = Math.max(s1, s2);
int y = Math.max(s3, s4);
boolean valid = true;
if (a[2] != x && a[2] != y)
valid = false;
if (a[3] != x && a[3] != y)
valid = false;
pw.println(valid ? "YES" : "NO");
}
pw.flush();
}
static public boolean[] sieve(int n) {
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;
}
static boolean isPalindrome(String str) {
// Pointers pointing to the beginning
// and the end of the string
int i = 0, j = str.length() - 1;
// While there are characters to compare
while (i < j) {
// If there is a mismatch
if (str.charAt(i) != str.charAt(j))
return false;
// Increment first pointer and
// decrement the other
i++;
j--;
}
// Given string is a palindrome
return true;
}
public static int primeFactors(int n) {
int count = 0;
// Print the number of 2s that divide n
while (n % 2 == 0) {
n /= 2;
}
if (n == 1)
return 0;
// n must be odd at this point. So we can
// skip one element (Note i = i +2)
for (int i = 3; i <= Math.sqrt(n); i += 2) {
// While i divides n, print i and divide n
while (n % i == 0) {
n /= i;
count++;
}
}
if (n > 1)
count++;
return count;
}
static int gcd(int a, int b) {
if (a == 0)
return b;
if (b == 0)
return a;
return gcd(b, a % b);
}
public static int[] swap(int data[], int left, int right) {
// Swap the data
int temp = data[left];
data[left] = data[right];
data[right] = temp;
// Return the updated array
return data;
}
static long nCrModp(int n, int r, int p) {
if (r > n - r)
r = n - r;
// The array C is going to store last
// row of pascal triangle at the end.
// And last entry of last row is nCr
int C[] = new int[r + 1];
C[0] = 1; // Top row of Pascal Triangle
// One by constructs remaining rows of Pascal
// Triangle from top to bottom
for (int i = 1; i <= n; i++) {
// Fill entries of current row using previous
// row values
for (int j = Math.min(i, r); j > 0; j--)
// nCj = (n-1)Cj + (n-1)C(j-1);
C[j] = (C[j] + C[j - 1]) % p;
}
return C[r];
}
static void sort(int[] a) {
ArrayList<Integer> l = new ArrayList<>();
for (int i : a)
l.add(i);
Collections.sort(l);
for (int i = 0; i < a.length; i++)
a[i] = l.get(i);
}
}
class Pair implements Comparable<Pair> {
int tower;
int value = 0;
Pair(int x, int y) {
tower = x;
value = y;
}
public int compareTo(Pair o) {
return this.value - o.value;
}
}
class Scanner {
BufferedReader br;
StringTokenizer st;
Scanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() throws IOException {
while (st == null || !st.hasMoreElements())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
int nextInt() throws NumberFormatException, IOException {
return Integer.parseInt(next());
}
int[] nextIntArray(int n) throws NumberFormatException, IOException {
int a[] = new int[n];
for (int i = 0; i < n; i++)
a[i] = Integer.parseInt(next());
return a;
}
long nextLong() throws NumberFormatException, IOException {
return Long.parseLong(next());
}
long[] nextLongArray(int n) throws NumberFormatException, IOException {
long a[] = new long[n];
for (int i = 0; i < n; i++)
a[i] = Long.parseLong(next());
return a;
}
double nextDouble() throws NumberFormatException, IOException {
return Double.parseDouble(next());
}
}
|
Vasya lagged behind at the University and got to the battlefield. Just joking! He's simply playing some computer game. The field is a flat platform with n trenches dug on it. The trenches are segments on a plane parallel to the coordinate axes. No two trenches intersect.
There is a huge enemy laser far away from Vasya. The laser charges for a seconds, and then shoots continuously for b seconds. Then, it charges for a seconds again. Then it shoots continuously for b seconds again and so on. Vasya knows numbers a and b. He also knows that while the laser is shooting, Vasya must be in the trench, but while the laser is charging, Vasya can safely move around the field. The main thing is to have time to hide in the trench before the shot. If Vasya reaches the trench exactly at the moment when the laser starts shooting, we believe that Vasya managed to hide. Coincidentally, the length of any trench in meters numerically does not exceed b.
Initially, Vasya is at point A. He needs to get to point B. Vasya moves at speed 1 meter per second in either direction. You can get in or out of the trench at any its point. Getting in or out of the trench takes no time. It is also possible to move in the trench, without leaving it.
What is the minimum time Vasya needs to get from point A to point B, if at the initial time the laser has just started charging? If Vasya cannot get from point A to point B, print -1. If Vasya reaches point B at the moment when the laser begins to shoot, it is believed that Vasya managed to reach point B.
Input
The first line contains two space-separated integers: a and b (1 ≤ a, b ≤ 1000), — the duration of charging and the duration of shooting, in seconds.
The second line contains four space-separated integers: Ax, Ay, Bx, By ( - 104 ≤ Ax, Ay, Bx, By ≤ 104) — the coordinates of points А and B. It is guaranteed that points A and B do not belong to any trench.
The third line contains a single integer: n (1 ≤ n ≤ 1000), — the number of trenches.
Each of the following n lines contains four space-separated integers: x1, y1, x2, y2 ( - 104 ≤ xi, yi ≤ 104) — the coordinates of ends of the corresponding trench.
All coordinates are given in meters. It is guaranteed that for any trench either x1 = x2, or y1 = y2. No two trenches intersect. The length of any trench in meters doesn't exceed b numerically.
Output
If Vasya can get from point A to point B, print the minimum time he will need for it. Otherwise, print number -1.
The answer will be considered correct if the absolute or relative error does not exceed 10 - 4
Examples
Input
2 4
0 5 6 5
3
0 0 0 4
1 1 4 1
6 0 6 4
Output
19.0000000000
Input
5 10
0 0 10 10
1
5 0 5 9
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
};
struct segment {
point a, b;
};
double G[1002][1002];
vector<segment> S;
int a, b;
int N;
double mins[1002];
bool used[1002];
double getLength(point a, point b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
bool someDirection(segment a, segment b) {
return (a.a.x == a.b.x && b.a.x == b.b.x) ||
(a.a.y == a.b.y && b.a.y == b.b.y);
}
bool isVertical(segment a) { return a.a.x == a.b.x; }
bool Inside(int f, int k, int l) {
return (f <= k && f >= l) || (f >= k && f <= l);
}
double minLength(segment a, segment b) {
if (someDirection(a, b)) {
int k, l;
if (isVertical(b) && isVertical(a)) {
k = abs(a.a.x - b.a.x);
if (Inside(a.a.y, b.a.y, b.b.y) || Inside(a.b.y, b.a.y, b.b.y) ||
Inside(b.a.y, a.a.y, a.b.y) || Inside(b.b.y, a.a.y, a.b.y))
l = 0;
else
l = min(abs(a.a.y - b.a.y),
min(abs(a.a.y - b.b.y),
min(abs(a.b.y - b.a.y), abs(a.b.y - b.b.y))));
} else {
k = abs(a.a.y - b.a.y);
if (Inside(a.a.x, b.a.x, b.b.x) || Inside(a.b.x, b.a.x, b.b.x) ||
Inside(b.a.x, a.a.x, a.b.x) || Inside(b.b.x, a.a.x, a.b.x))
l = 0;
else
l = min(abs(a.a.x - b.a.x),
min(abs(a.a.x - b.b.x),
min(abs(a.b.x - b.a.x), abs(a.b.x - b.b.x))));
}
return sqrt(k * k + l * l);
} else {
if (isVertical(b)) swap(a, b);
int k, l;
if (abs(a.a.x - b.a.x) + abs(a.a.x - b.b.x) == abs(b.a.x - b.b.x))
k = 0;
else
k = min(abs(a.a.x - b.a.x), abs(a.a.x - b.b.x));
if (abs(b.a.y - a.a.y) + abs(b.a.y - a.b.y) == abs(a.a.y - a.b.y))
l = 0;
else
l = min(abs(b.a.y - a.a.y), abs(b.a.y - a.b.y));
return sqrt(k * k + l * l);
}
}
void FormMatrix() {
for (int i = 0; i < S.size(); i++)
for (int j = 0; j < S.size(); j++) {
G[i][j] = minLength(S[i], S[j]);
}
}
void Dijkstra() {
for (int i = 0; i < N + 2; i++) {
mins[i] = 4294967296;
used[i] = false;
}
mins[0] = 0;
for (int i = 0; i < N + 2; i++) {
int v = -1;
for (int j = 0; j < N + 2; j++)
if (!used[j] && (v == -1 || mins[j] < mins[v])) v = j;
used[v] = true;
for (int j = 0; j < N + 2; j++) {
if (mins[j] > (ceil(mins[v] / (a + b))) * (a + b) + G[v][j] &&
G[v][j] <= a)
mins[j] = ceil(mins[v] / (a + b)) * (a + b) + G[v][j];
}
}
}
int main() {
cin >> a >> b;
segment alpha, beta;
cin >> alpha.a.x >> alpha.a.y;
alpha.b.x = alpha.a.x;
alpha.b.y = alpha.a.y;
cin >> beta.a.x >> beta.a.y;
beta.b.x = beta.a.x;
beta.b.y = beta.a.y;
S.push_back(alpha);
S.push_back(beta);
cin >> N;
for (int i = 0; i < N; i++) {
segment gamma;
cin >> gamma.a.x >> gamma.a.y >> gamma.b.x >> gamma.b.y;
S.push_back(gamma);
}
FormMatrix();
Dijkstra();
cout.setf(ios::fixed);
cout.precision(5);
if (mins[1] == 4294967296)
cout << -1 << endl;
else
cout << mins[1] << endl;
return 0;
}
|
The Little Elephant very much loves sums on intervals.
This time he has a pair of integers l and r (l ≤ r). The Little Elephant has to find the number of such integers x (l ≤ x ≤ r), that the first digit of integer x equals the last one (in decimal notation). For example, such numbers as 101, 477474 or 9 will be included in the answer and 47, 253 or 1020 will not.
Help him and count the number of described numbers x for a given pair l and r.
Input
The single line contains a pair of integers l and r (1 ≤ l ≤ r ≤ 1018) — the boundaries of the interval.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
On a single line print a single integer — the answer to the problem.
Examples
Input
2 47
Output
12
Input
47 1024
Output
98
Note
In the first sample the answer includes integers 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44.
|
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class LittleElephantAndInterval {
static long calc(long x) {
if (x < 10)
return x;
String a = Long.toString(x);
if (a.charAt(0) <= a.charAt(a.length() - 1))
return x / 10 + 9;
return x / 10 + 8;
}
public static void main(String[] args) throws IOException {
MyScanner sc = new MyScanner(System.in);
PrintWriter out = new PrintWriter(System.out);
out.println(-calc(sc.nextLong() - 1) + calc(sc.nextLong()));
out.flush();
out.close();
}
static class MyScanner {
BufferedReader br;
StringTokenizer st;
MyScanner(InputStream is) {
br = new BufferedReader(new InputStreamReader(is));
}
MyScanner(String filename) throws IOException {
br = new BufferedReader(new FileReader(new File(filename)));
}
String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
String nextLine() throws IOException {
return br.readLine();
}
int nextInt() throws IOException {
return Integer.parseInt(next());
}
long nextLong() throws IOException {
return Long.parseLong(next());
}
boolean ready() throws IOException {
return br.ready();
}
}
}
|
Bob wants to put a new bargaining table in his office. To do so he measured the office room thoroughly and drew its plan: Bob's office room is a rectangular room n × m meters. Each square meter of the room is either occupied by some furniture, or free. A bargaining table is rectangular, and should be placed so, that its sides are parallel to the office walls. Bob doesn't want to change or rearrange anything, that's why all the squares that will be occupied by the table should be initially free. Bob wants the new table to sit as many people as possible, thus its perimeter should be maximal. Help Bob find out the maximum possible perimeter of a bargaining table for his office.
Input
The first line contains 2 space-separated numbers n and m (1 ≤ n, m ≤ 25) — the office room dimensions. Then there follow n lines with m characters 0 or 1 each. 0 stands for a free square meter of the office room. 1 stands for an occupied square meter. It's guaranteed that at least one square meter in the room is free.
Output
Output one number — the maximum possible perimeter of a bargaining table for Bob's office room.
Examples
Input
3 3
000
010
000
Output
8
Input
5 4
1100
0000
0000
0000
0000
Output
16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
char mat[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> mat[i][j];
int peri = 0;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++)
for (int k = 0; k < m; k++)
for (int l = k; l < m; l++) {
bool c = true;
for (int x = i; x <= j; x++)
for (int y = k; y <= l; y++)
if (mat[x][y] == '1') c = false;
if (c) peri = max(peri, 2 * (j - i + l - k + 2));
}
cout << peri;
}
|
Greg is a beginner bodybuilder. Today the gym coach gave him the training plan. All it had was n integers a1, a2, ..., an. These numbers mean that Greg needs to do exactly n exercises today. Besides, Greg should repeat the i-th in order exercise ai times.
Greg now only does three types of exercises: "chest" exercises, "biceps" exercises and "back" exercises. Besides, his training is cyclic, that is, the first exercise he does is a "chest" one, the second one is "biceps", the third one is "back", the fourth one is "chest", the fifth one is "biceps", and so on to the n-th exercise.
Now Greg wonders, which muscle will get the most exercise during his training. We know that the exercise Greg repeats the maximum number of times, trains the corresponding muscle the most. Help Greg, determine which muscle will get the most training.
Input
The first line contains integer n (1 ≤ n ≤ 20). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 25) — the number of times Greg repeats the exercises.
Output
Print word "chest" (without the quotes), if the chest gets the most exercise, "biceps" (without the quotes), if the biceps gets the most exercise and print "back" (without the quotes) if the back gets the most exercise.
It is guaranteed that the input is such that the answer to the problem is unambiguous.
Examples
Input
2
2 8
Output
biceps
Input
3
5 1 10
Output
back
Input
7
3 3 2 7 9 6 8
Output
chest
Note
In the first sample Greg does 2 chest, 8 biceps and zero back exercises, so the biceps gets the most exercises.
In the second sample Greg does 5 chest, 1 biceps and 10 back exercises, so the back gets the most exercises.
In the third sample Greg does 18 chest, 12 biceps and 8 back exercises, so the chest gets the most exercise.
|
n=int(input())
l=list(map(int,input().split()))
chest=back=biceps=0
for i in range(0,n,3):
chest+=l[i]
for i in range(1,n,3):
biceps+=l[i]
for i in range(2,n,3):
back+=l[i]
if chest>biceps and chest>back:
print("chest")
elif biceps>chest and biceps>back:
print("biceps")
else:
print("back")
|
Valera the horse lives on a plane. The Cartesian coordinate system is defined on this plane. Also an infinite spiral is painted on the plane. The spiral consists of segments: [(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), ( - 1, 1)], [( - 1, 1), ( - 1, - 1)], [( - 1, - 1), (2, - 1)], [(2, - 1), (2, 2)] and so on. Thus, this infinite spiral passes through each integer point of the plane.
Valera the horse lives on the plane at coordinates (0, 0). He wants to walk along the spiral to point (x, y). Valera the horse has four legs, so he finds turning very difficult. Count how many times he will have to turn if he goes along a spiral from point (0, 0) to point (x, y).
Input
The first line contains two space-separated integers x and y (|x|, |y| ≤ 100).
Output
Print a single integer, showing how many times Valera has to turn.
Examples
Input
0 0
Output
0
Input
1 0
Output
0
Input
0 1
Output
2
Input
-1 -1
Output
3
|
import java.util.Arrays;
import java.util.Scanner;
public class A {
public static boolean between(int x, int st, int end) {
return x <= Math.max(st,end) && x >= Math.min(st,end);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
int y = sc.nextInt();
if (x == 0 && y == 0) {
System.out.println(0);
return;
}
int level = Math.max(Math.abs(x), Math.abs(y));
int res = (level - 1) * 4;
// System.out.println(res);
int[] X = new int[5];
int[] Y = new int[5];
X[0] = level;
Y[0] = -(level - 1);
X[1] = level;
Y[1] = level;
X[2] = -level;
Y[2] = level;
X[3] =-level;
Y[3] = -level;
X[4] = level;
Y[4] = -level;
// System.out.println(Arrays.toString(X));
// System.out.println(Arrays.toString(Y));
for (int i = 0; i < 4; i++) {
if(X[i]==x&&Y[i]==y){
System.out.println(res+i);
return;
}
if (between(x, X[i], X[i + 1]) && between(y, Y[i], Y[i + 1])) {
System.out.println(res + i+1);
return;
}
}
}
}
|
In a far away galaxy there is war again. The treacherous Republic made k precision strikes of power ai on the Empire possessions. To cope with the republican threat, the Supreme Council decided to deal a decisive blow to the enemy forces.
To successfully complete the conflict, the confrontation balance after the blow should be a positive integer. The balance of confrontation is a number that looks like <image>, where p = n! (n is the power of the Imperial strike), <image>. After many years of war the Empire's resources are low. So to reduce the costs, n should be a minimum positive integer that is approved by the commanders.
Help the Empire, find the minimum positive integer n, where the described fraction is a positive integer.
Input
The first line contains integer k (1 ≤ k ≤ 106). The second line contains k integers a1, a2, ..., ak (1 ≤ ai ≤ 107).
Output
Print the minimum positive integer n, needed for the Empire to win.
Please, do not use the %lld to read or write 64-but integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
2
1000 1000
Output
2000
Input
1
2
Output
2
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool MinPlace(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool MaxPlace(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename S, typename T>
ostream &operator<<(ostream &out, const pair<S, T> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
for (int i = 0; i < (int)v.size(); i++) {
out << v[i];
if (i != (int)v.size() - 1) out << ", ";
}
out << "]";
return out;
}
template <int maxm = 1000005>
class sieve {
private:
bool doPhi, doMo;
public:
bitset<maxm + 10> isnp;
vector<int> prime, mo, phi, primes;
sieve(bool doPhi = false, bool doMo = false) : doPhi(doPhi), doMo(doMo) {
prime.resize(maxm + 10, 0);
if (doMo) mo.resize(maxm + 10);
if (doPhi) {
phi.resize(maxm + 10);
for (int i = 0; i <= maxm; i++) phi[i] = i;
}
if (doMo) {
mo[1] = 1;
mo[2] = mo[3] = -1;
mo[4] = 0;
}
if (doPhi) {
phi[1] = phi[2] = 1;
phi[3] = phi[4] = 2;
}
prime[1] = 1;
isnp[1] = true;
primeWork(2);
primeWork(3);
for (int i = 5; i <= maxm; i += 6) {
for (int j = i; j <= min(i + 2, maxm); j += 2)
if (!isnp[j]) primeWork(j);
if (doMo || doPhi)
for (int j = i; j <= min(i + 5, maxm); j++) {
bool rem = (j / prime[j]) % prime[j];
if (doMo) mo[j] = rem * (-mo[j / prime[j]]);
if (doPhi) phi[j] = phi[j / prime[j]] * (prime[j] - rem);
}
}
}
void primeWork(long long int pr) {
prime[pr] = pr;
primes.push_back(pr);
for (long long int k = pr * pr; k <= maxm; k += pr) {
if (!isnp[k]) {
prime[k] = pr;
isnp[k] = true;
}
}
}
bool isprime(int n) {
assert(n <= maxm);
return !isnp[n];
}
};
long long int cnt[int(1e7) + 1] = {};
int a[int(1e7) + 1];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int sum = 0;
int k, maxm = 0;
sieve<10000005> s;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + k);
for (int i = 0, j = 2; i < k; i++) {
while (a[i] >= j) {
int no = j++;
while (no > 1) {
cnt[s.prime[no]] += (k - i);
no /= s.prime[no];
}
}
}
long long int l = 1, r = sum;
while (l <= r) {
long long int mid = (l + r) / 2;
bool cool = true;
for (auto pr : s.primes) {
if (pr > a[k - 1]) break;
long long int target = cnt[pr], test = mid, test_cnt = 0;
while (test) test_cnt += (test /= pr);
if (test_cnt < target) {
cool = false;
break;
}
}
if (cool)
r = mid - 1;
else
l = mid + 1;
}
cout << l;
}
|
There is a long plate s containing n digits. Iahub wants to delete some digits (possibly none, but he is not allowed to delete all the digits) to form his "magic number" on the plate, a number that is divisible by 5. Note that, the resulting number may contain leading zeros.
Now Iahub wants to count the number of ways he can obtain magic number, modulo 1000000007 (109 + 7). Two ways are different, if the set of deleted positions in s differs.
Look at the input part of the statement, s is given in a special form.
Input
In the first line you're given a string a (1 ≤ |a| ≤ 105), containing digits only. In the second line you're given an integer k (1 ≤ k ≤ 109). The plate s is formed by concatenating k copies of a together. That is n = |a|·k.
Output
Print a single integer — the required number of ways modulo 1000000007 (109 + 7).
Examples
Input
1256
1
Output
4
Input
13990
2
Output
528
Input
555
2
Output
63
Note
In the first case, there are four possible ways to make a number that is divisible by 5: 5, 15, 25 and 125.
In the second case, remember to concatenate the copies of a. The actual plate is 1399013990.
In the third case, except deleting all digits, any choice will do. Therefore there are 26 - 1 = 63 possible ways to delete digits.
|
#include <bits/stdc++.h>
using namespace std;
string s;
int n;
long long inverse(long long a, long long b, long long *X, long long *Y) {
if (b == 0) {
*X = 1;
*Y = 0;
return a;
} else {
long long xx, yy;
long long ret = inverse(b, a % b, &xx, &yy);
*X = yy;
*Y = xx - (a / b) * yy;
return ret;
}
}
long long power(int base, int exp) {
if (exp == 0) return 1LL;
if (exp % 2) return (power(base, exp - 1) * base) % 1000000007;
long long x = power(base, exp / 2);
return (x * x) % 1000000007;
}
int main() {
cin >> s >> n;
int len = s.size();
long long r = power(2, len);
long long ans = 0;
for (int i = 0; i < len; i++) {
if (s[i] == '0' || s[i] == '5') {
long long ppp =
((power(2, i) * ((power(r, n) - 1 + 1000000007) % 1000000007)) %
1000000007);
long long x, y;
inverse(r - 1, 1000000007, &x, &y);
x = (x + 1000000007) % 1000000007;
ppp = ppp * x;
ppp %= 1000000007;
ans += ppp;
ans %= 1000000007;
}
}
cout << ans << endl;
}
|
You are given a rooted tree with n vertices. In each leaf vertex there's a single integer — the number of apples in this vertex.
The weight of a subtree is the sum of all numbers in this subtree leaves. For instance, the weight of a subtree that corresponds to some leaf is the number written in the leaf.
A tree is balanced if for every vertex v of the tree all its subtrees, corresponding to the children of vertex v, are of equal weight.
Count the minimum number of apples that you need to remove from the tree (specifically, from some of its leaves) in order to make the tree balanced. Notice that you can always achieve the goal by just removing all apples.
Input
The first line contains integer n (2 ≤ n ≤ 105), showing the number of vertices in the tree. The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 108), ai is the number of apples in the vertex number i. The number of apples in non-leaf vertices is guaranteed to be zero.
Then follow n - 1 lines, describing the tree edges. Each line contains a pair of integers xi, yi (1 ≤ xi, yi ≤ n, xi ≠ yi) — the vertices connected by an edge.
The vertices are indexed from 1 to n. Vertex 1 is the root.
Output
Print a single integer — the minimum number of apples to remove in order to make the tree balanced.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the sin, cout streams cin, cout or the %I64d specifier.
Examples
Input
6
0 0 12 13 5 6
1 2
1 3
1 4
2 5
2 6
Output
6
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = (1 << 29) + 5;
const long long int LLINF = (1ll << 59) + 5;
const int MOD = 1000 * 1000 * 1000 + 7;
const int MAX_N = 1000 * 100 + 5;
int n;
vector<int> graph[MAX_N];
long long int cnt[MAX_N];
long long int dp[MAX_N];
long long int answer = 0;
long long int gcd(long long int a, long long int b) {
return ((b) ? gcd(b, a % b) : a);
}
void dfs(int v, int p) {
long long int min_of = LLINF;
dp[v] = 1;
for (int i = 0; i < graph[v].size(); ++i) {
if (graph[v][i] != p) {
dfs(graph[v][i], v);
dp[v] = (dp[v] / gcd(dp[v], dp[graph[v][i]])) * dp[graph[v][i]];
cnt[v] += cnt[graph[v][i]];
min_of = min(min_of, cnt[graph[v][i]]);
}
}
if (min_of != LLINF) {
answer +=
cnt[v] - (min_of - min_of % dp[v]) *
((long long int)graph[v].size() - ((v == 0) ? 0 : 1));
cnt[v] = (min_of - min_of % dp[v]) *
((long long int)graph[v].size() - ((v == 0) ? 0 : 1));
}
if (((long long int)graph[v].size() - ((v == 0) ? 0 : 1)) != 0) {
dp[v] *= ((long long int)graph[v].size() - ((v == 0) ? 0 : 1));
}
if (dp[v] == 0) {
dp[v] = 1;
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%lld", &cnt[i]);
}
int v1, v2;
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d", &v1, &v2);
--v1;
--v2;
graph[v1].push_back(v2);
graph[v2].push_back(v1);
}
dfs(0, -1);
printf("%lld", answer);
fclose(stdin);
fclose(stdout);
return 0;
}
|
There are a set of points S on the plane. This set doesn't contain the origin O(0, 0), and for each two distinct points in the set A and B, the triangle OAB has strictly positive area.
Consider a set of pairs of points (P1, P2), (P3, P4), ..., (P2k - 1, P2k). We'll call the set good if and only if:
* k ≥ 2.
* All Pi are distinct, and each Pi is an element of S.
* For any two pairs (P2i - 1, P2i) and (P2j - 1, P2j), the circumcircles of triangles OP2i - 1P2j - 1 and OP2iP2j have a single common point, and the circumcircle of triangles OP2i - 1P2j and OP2iP2j - 1 have a single common point.
Calculate the number of good sets of pairs modulo 1000000007 (109 + 7).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of points in S. Each of the next n lines contains four integers ai, bi, ci, di (0 ≤ |ai|, |ci| ≤ 50; 1 ≤ bi, di ≤ 50; (ai, ci) ≠ (0, 0)). These integers represent a point <image>.
No two points coincide.
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
10
-46 46 0 36
0 20 -24 48
-50 50 -49 49
-20 50 8 40
-15 30 14 28
4 10 -4 5
6 15 8 10
-20 50 -3 15
4 34 -16 34
16 34 2 17
Output
2
Input
10
30 30 -26 26
0 15 -36 36
-28 28 -34 34
10 10 0 4
-8 20 40 50
9 45 12 30
6 15 7 35
36 45 -8 20
-16 34 -4 34
4 34 8 17
Output
4
Input
10
0 20 38 38
-30 30 -13 13
-11 11 16 16
30 30 0 37
6 30 -4 10
6 15 12 15
-4 5 -10 25
-16 20 4 10
8 17 -2 17
16 34 2 17
Output
10
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int MOD = 1000000007;
int n, pot[1000100];
pair<double, double> a[1010];
bool cmp(const pair<double, double> &A, const pair<double, double> &B) {
if (abs(A.first - B.first) > eps) return A.first < B.first;
if (abs(A.second - B.second) > eps) return A.second < B.second;
return 0;
}
struct seg {
double x, y, ang;
seg() {}
seg(pair<double, double> A, pair<double, double> B) {
x = A.first + B.first;
y = A.second + B.second;
ang = atan2(A.second - B.second, A.first - B.first);
}
seg(double ang) : ang(ang) {}
bool operator<(const seg &A) const {
if (abs(x - A.x) > eps) return x < A.x;
if (abs(y - A.y) > eps) return y < A.y;
if (abs(ang - A.ang) > eps) return ang < A.ang;
return 0;
}
};
vector<seg> V;
vector<int> cnt;
int calc() {
int ret = 1, sum = 0;
for (int i = 0; i < (int)cnt.size(); ++i)
ret = ((long long)ret * (cnt[i] + 1)) % MOD, sum += cnt[i];
return (ret - 1 - sum + MOD) % MOD;
}
int main() {
pot[0] = 1;
for (int i = 1; i < 1000005; ++i) pot[i] = (long long)pot[i - 1] * 2 % MOD;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int A, B, C, D;
scanf("%d%d%d%d", &A, &B, &C, &D);
double x = (double)A / B, y = (double)C / D;
double X = x / (x * x + y * y), Y = y / (x * x + y * y);
a[i] = pair<double, double>(X, Y);
}
sort(a, a + n, cmp);
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) {
V.push_back(seg(a[i], a[j]));
}
sort(V.begin(), V.end());
V.push_back(seg(-100));
int ans = 0;
cnt.push_back(1);
for (int i = 1; i < (int)V.size(); ++i) {
if (abs(V[i].x - V[i - 1].x) > eps || abs(V[i].y - V[i - 1].y) > eps) {
ans = (ans + calc()) % MOD;
cnt.clear();
cnt.push_back(1);
} else if (abs(V[i].ang - V[i - 1].ang) > eps)
cnt.push_back(1);
else
++cnt.back();
}
printf("%d\n", ans);
return 0;
}
|
Teacher thinks that we make a lot of progress. Now we are even allowed to use decimal notation instead of counting sticks. After the test the teacher promised to show us a "very beautiful number". But the problem is, he's left his paper with the number in the teachers' office.
The teacher remembers that the "very beautiful number" was strictly positive, didn't contain any leading zeroes, had the length of exactly p decimal digits, and if we move the last digit of the number to the beginning, it grows exactly x times. Besides, the teacher is sure that among all such numbers the "very beautiful number" is minimal possible.
The teachers' office isn't near and the teacher isn't young. But we've passed the test and we deserved the right to see the "very beautiful number". Help to restore the justice, find the "very beautiful number" for us!
Input
The single line contains integers p, x (1 ≤ p ≤ 106, 1 ≤ x ≤ 9).
Output
If the teacher's made a mistake and such number doesn't exist, then print on a single line "Impossible" (without the quotes). Otherwise, print the "very beautiful number" without leading zeroes.
Examples
Input
6 5
Output
142857
Input
1 2
Output
Impossible
Input
6 4
Output
102564
Note
Sample 1: 142857·5 = 714285.
Sample 2: The number that consists of a single digit cannot stay what it is when multiplied by 2, thus, the answer to the test sample is "Impossible".
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
long long int gcd(long long int x, long long int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
long long int logx(long long int base, long long int num) {
int cnt = 0;
while (num != 1) {
num /= base;
++cnt;
}
return cnt;
}
vector<long long int> vin(long long int n) {
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
return a;
}
void in(long long int *a, long long int n) {
for (long long int i = 0; i < n; i++) cin >> a[i];
}
void out(long long int *a, long long int n) {
for (long long int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << '\n';
}
void vout(vector<long long int> v) {
for (long long int i = 0; i < (long long int)v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;
}
const long long int maxN = (long long int)(1 * 1e6 + 7);
vector<long long int> a(maxN);
void solve() {
long long int n, x;
cin >> n >> x;
for (long long int i = 1; i <= 9; i++) {
a[0] = i;
long long int c = 0;
for (long long int j = 1; j <= n; j++) {
a[j] = (a[j - 1] * x + c) % 10;
c = (a[j - 1] * x + c) / 10;
}
if (a[n] == i && c == 0 && a[n - 1] != 0) {
for (long long int j = n - 1; j >= 0; j--) {
cout << a[j];
}
cout << '\n';
return;
}
}
cout << "Impossible\n";
}
int main() {
fast();
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int main() {
cin >> n >> k;
int total = (n * (n - 1)) / 2;
if (total >= n * k) {
total = n * k;
cout << total << "\n";
int nod1 = 1;
int nod2 = nod1 + 1;
int cate = 0;
while (total > 0) {
cate++;
if (nod2 > n) nod2 = 1;
cout << nod1 << " " << nod2 << "\n";
if (cate == k) {
nod1++;
nod2 = nod1 + 1;
cate = 0;
} else
nod2++;
total--;
}
} else
cout << -1 << "\n";
}
|
DZY loves Physics, and he enjoys calculating density.
Almost everything has density, even a graph. We define the density of a non-directed graph (nodes and edges of the graph have some values) as follows:
<image> where v is the sum of the values of the nodes, e is the sum of the values of the edges.
Once DZY got a graph G, now he wants to find a connected induced subgraph G' of the graph, such that the density of G' is as large as possible.
An induced subgraph G'(V', E') of a graph G(V, E) is a graph that satisfies:
* <image>;
* edge <image> if and only if <image>, and edge <image>;
* the value of an edge in G' is the same as the value of the corresponding edge in G, so as the value of a node.
Help DZY to find the induced subgraph with maximum density. Note that the induced subgraph you choose must be connected.
<image>
Input
The first line contains two space-separated integers n (1 ≤ n ≤ 500), <image>. Integer n represents the number of nodes of the graph G, m represents the number of edges.
The second line contains n space-separated integers xi (1 ≤ xi ≤ 106), where xi represents the value of the i-th node. Consider the graph nodes are numbered from 1 to n.
Each of the next m lines contains three space-separated integers ai, bi, ci (1 ≤ ai < bi ≤ n; 1 ≤ ci ≤ 103), denoting an edge between node ai and bi with value ci. The graph won't contain multiple edges.
Output
Output a real number denoting the answer, with an absolute or relative error of at most 10 - 9.
Examples
Input
1 0
1
Output
0.000000000000000
Input
2 1
1 2
1 2 1
Output
3.000000000000000
Input
5 6
13 56 73 98 17
1 2 56
1 3 29
1 4 42
2 3 95
2 4 88
3 4 63
Output
2.965517241379311
Note
In the first sample, you can only choose an empty subgraph, or the subgraph containing only node 1.
In the second sample, choosing the whole graph is optimal.
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1000 + 100;
vector<pair<int, int> > G[MX];
bitset<MX> bs;
struct data {
int v, f, t;
bool operator<(const data& in) const { return v < in.v; }
};
int val[MX];
int main() {
srand(time(0));
int n, e;
cin >> n >> e;
if (e == 0) {
cout << "0.000000000000000";
exit(0);
}
for (int i = 1; i < n + 1; i++) {
cin >> val[i];
}
while (e--) {
int s, d, v;
cin >> s >> d >> v;
G[s].push_back({d, v});
G[d].push_back({s, v});
}
long double ans = 0;
for (int i = 1; i < n + 1; i++) {
long double v_sum = val[i], e_sum = 0;
long double local_max = 0;
bs.reset();
priority_queue<data> pq;
for (auto it : G[i]) pq.push((data){-it.second, i, it.first});
bs[i] = true;
while (pq.size()) {
int next = pq.top().t;
int from = pq.top().f;
int vl = pq.top().v;
pq.pop();
if (bs[next]) continue;
bs[next] = true;
if ((v_sum + val[next]) / (e_sum - vl) > ans) {
local_max = max((v_sum + val[next]) / (e_sum - vl), local_max);
e_sum -= vl;
v_sum += val[next];
for (auto it : G[next]) {
pq.push((data){-it.second, next, it.first});
}
}
}
ans = max(ans, local_max);
}
cout << fixed << setprecision(15) << ans;
}
|
The start of the new academic year brought about the problem of accommodation students into dormitories. One of such dormitories has a a × b square meter wonder room. The caretaker wants to accommodate exactly n students there. But the law says that there must be at least 6 square meters per student in a room (that is, the room for n students must have the area of at least 6n square meters). The caretaker can enlarge any (possibly both) side of the room by an arbitrary positive integer of meters. Help him change the room so as all n students could live in it and the total area of the room was as small as possible.
Input
The first line contains three space-separated integers n, a and b (1 ≤ n, a, b ≤ 109) — the number of students and the sizes of the room.
Output
Print three integers s, a1 and b1 (a ≤ a1; b ≤ b1) — the final area of the room and its sizes. If there are multiple optimal solutions, print any of them.
Examples
Input
3 3 5
Output
18
3 6
Input
2 4 4
Output
16
4 4
|
n,a,b = map(int, input().split(' '))
A = 6*n
if a*b >= 6*n :
print(a*b)
print(a,b)
else :
R = []
temp = float("INF")
for i in range(1, int(A**0.5)+2) :
j = A//i
if i*j < A : j+=1
x = max([a,b,i,j])
y = max(min(a,b) , min(i,j))
if temp > x*y :
temp = x*y
if b>a : x,y = y,x
R = [x,y, temp]
print(R[2])
print(R[0], R[1])
|
An n × n square matrix is special, if:
* it is binary, that is, each cell contains either a 0, or a 1;
* the number of ones in each row and column equals 2.
You are given n and the first m rows of the matrix. Print the number of special n × n matrices, such that the first m rows coincide with the given ones.
As the required value can be rather large, print the remainder after dividing the value by the given number mod.
Input
The first line of the input contains three integers n, m, mod (2 ≤ n ≤ 500, 0 ≤ m ≤ n, 2 ≤ mod ≤ 109). Then m lines follow, each of them contains n characters — the first rows of the required special matrices. Each of these lines contains exactly two characters '1', the rest characters are '0'. Each column of the given m × n table contains at most two numbers one.
Output
Print the remainder after dividing the required value by number mod.
Examples
Input
3 1 1000
011
Output
2
Input
4 4 100500
0110
1010
0101
1001
Output
1
Note
For the first test the required matrices are:
011
101
110
011
110
101
In the second test the required matrix is already fully given, so the answer is 1.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
long long dp[N][N];
int mod, n, m, sum[N];
long long C(int a) { return (long long)a * (a - 1) / 2; }
long long dfs(int a, int b) {
if (a < 0 || b < 0) return 0;
if (a == 0 && b == 0) return 1;
if (~dp[a][b]) return dp[a][b];
dp[a][b] = 0;
dp[a][b] += C(a) * dfs(a - 2, b) % mod;
dp[a][b] += C(b) * dfs(a + 2, b - 2) % mod;
dp[a][b] += a * b * dfs(a, b - 1) % mod;
dp[a][b] %= mod;
return dp[a][b];
}
int main() {
char s[N];
memset(dp, -1, sizeof dp);
while (cin >> n >> m >> mod) {
memset(sum, 0, sizeof sum);
for (int i = 0; i < m; i++) {
scanf("%s", s);
for (int j = 0; j < n; j++) sum[j] += s[j] - '0';
}
int a = 0, b = 0;
for (int i = 0; i < n; i++)
if (sum[i] == 1)
a++;
else if (sum[i] == 0)
b++;
cout << dfs(a, b) << endl;
}
return 0;
}
|
You need to find a binary tree of size n that satisfies a given set of c constraints. Suppose that the nodes of the unknown binary tree are labeled using a pre-order traversal starting with 1. For the i-th constraint you are given two labels, ai and bi and a direction, left or right. In case of left direction, bi is an element of the subtree rooted at ai's left child. Similarly in the case of right direction bi is an element of the subtree rooted at ai's right child.
Input
The first line of input contains two integers n and c. The next c lines contain 2 integers ai, bi (1 ≤ ai, bi ≤ n) and either "LEFT" or "RIGHT" denoting whether b is in the subtree rooted at ai's left child or in the subtree rooted at ai's right child.
The problem consists of multiple subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem D1 (9 points), the constraints 1 ≤ n ≤ 100, 1 ≤ c ≤ 50 will hold.
* In subproblem D2 (8 points), the constraints 1 ≤ n ≤ 1000000, 1 ≤ c ≤ 100000 will hold.
Output
Output will be on a single line.
Any binary tree that satisfies the constraints will be accepted. The tree's nodes should be printed out as n space separated labels representing an in-order traversal, using the pre-order numbers as labels of vertices.
If there are no trees that satisfy the constraints, print "IMPOSSIBLE" (without quotes).
Examples
Input
3 2
1 2 LEFT
1 3 RIGHT
Output
2 1 3
Input
3 2
1 2 RIGHT
1 3 LEFT
Output
IMPOSSIBLE
Note
Consider the first sample test. We need to find a tree with 3 nodes that satisfies the following two constraints. The node labeled 2 with pre-order traversal should be in the left subtree of the node labeled 1 with pre-order traversal; the node labeled 3 with pre-order traversal should be in the right subtree of the node labeled 1. There is only one tree with three nodes that satisfies these constraints and its in-order traversal is (2, 1, 3).
Pre-order is the "root – left subtree – right subtree" order. In-order is the "left subtree – root – right subtree" order.
For other information regarding in-order and pre-order, see <http://en.wikipedia.org/wiki/Tree_traversal>.
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
int n, c;
set<int> sl[1111111];
set<int> sr[1111111];
int LN[1111111];
int RN[1111111];
void print_tree(int pos) {
if (LN[pos] != -1) print_tree(LN[pos]);
printf("%d ", pos);
if (RN[pos] != -1) print_tree(RN[pos]);
}
int START;
bool go(bool force, int MN = -1) {
if (START > n + 1) return false;
int ver = START;
START++;
if (START == n + 1) {
if (!(sl[ver].empty() && sr[ver].empty())) return false;
return true;
}
if (sl[ver].empty() && sr[ver].empty() && MN < START) {
if (!force) return true;
RN[ver] = START;
return go(force);
}
if (!sl[ver].empty()) {
LN[ver] = START;
if (*(--sl[ver].end()) < START) return false;
if (!go(false, *(--sl[ver].end()))) return false;
}
if (sr[ver].empty()) {
if (force || MN >= START) {
if (START == n + 1) return true;
RN[ver] = START;
if (!go(force, MN)) return false;
}
} else {
RN[ver] = START;
if (*(sr[ver].begin()) < START) return false;
if (*(--sr[ver].end()) < START) return false;
if (!go(force, max(MN, *(--sr[ver].end())))) return false;
}
return true;
}
int main() {
cin >> n >> c;
char _s[10];
for (int i = (0); i < (c); i++) {
int a, b;
scanf("%d %d %s", &a, &b, _s);
if (a >= b) {
puts("IMPOSSIBLE");
return 0;
}
if (_s[0] == 'L')
sl[a].insert(b);
else
sr[a].insert(b);
}
memset(LN, -1, sizeof LN);
memset(RN, -1, sizeof RN);
START = 1;
if (!go(1)) {
puts("IMPOSSIBLE");
} else {
if (START != n + 1)
puts("IMPOSSIBLE");
else
print_tree(1);
}
return 0;
}
|
Andrew skipped lessons on the subject 'Algorithms and Data Structures' for the entire term. When he came to the final test, the teacher decided to give him a difficult task as a punishment.
The teacher gave Andrew an array of n numbers a1, ..., an. After that he asked Andrew for each k from 1 to n - 1 to build a k-ary heap on the array and count the number of elements for which the property of the minimum-rooted heap is violated, i.e. the value of an element is less than the value of its parent.
Andrew looked up on the Wikipedia that a k-ary heap is a rooted tree with vertices in elements of the array. If the elements of the array are indexed from 1 to n, then the children of element v are elements with indices k(v - 1) + 2, ..., kv + 1 (if some of these elements lie outside the borders of the array, the corresponding children are absent). In any k-ary heap every element except for the first one has exactly one parent; for the element 1 the parent is absent (this element is the root of the heap). Denote p(v) as the number of the parent of the element with the number v. Let's say that for a non-root element v the property of the heap is violated if av < ap(v).
Help Andrew cope with the task!
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105).
The second line contains n space-separated integers a1, ..., an ( - 109 ≤ ai ≤ 109).
Output
in a single line print n - 1 integers, separate the consecutive numbers with a single space — the number of elements for which the property of the k-ary heap is violated, for k = 1, 2, ..., n - 1.
Examples
Input
5
1 5 4 3 2
Output
3 2 1 0
Input
6
2 2 2 2 2 2
Output
0 0 0 0 0
Note
Pictures with the heaps for the first sample are given below; elements for which the property of the heap is violated are marked with red.
<image> <image> <image> <image>
In the second sample all elements are equal, so the property holds for all pairs.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 210000;
int fenw[MAXN];
int a[MAXN], ans[MAXN];
int sum(int x) {
int sum = 0;
for (; x >= 0; x &= x + 1, --x) sum += fenw[x];
return sum;
}
void add(int x, int z) {
for (; x < MAXN; x |= x + 1) fenw[x] += z;
}
int main(int argc, const char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 0; i < (int)(n); ++i) {
cin >> a[i];
}
vector<pair<int, int> > b;
for (int i = 0; i < (int)(n); ++i) {
b.push_back(make_pair(a[i], i));
}
sort((b).begin(), (b).end());
for (pair<int, int> p : b) {
int i = p.second;
for (int k(1); k * i + 1 < n && k < n; k++) {
ans[k] += sum(min(k * i + k, n)) - sum(k * i);
}
add(i, 1);
}
for (int k = 1; k <= (int)(n - 1); ++k) {
cout << ans[k] << ' ';
}
return 0;
}
|
Two kittens, Max and Min, play with a pair of non-negative integers x and y. As you can guess from their names, kitten Max loves to maximize and kitten Min loves to minimize. As part of this game Min wants to make sure that both numbers, x and y became negative at the same time, and kitten Max tries to prevent him from doing so.
Each kitten has a set of pairs of integers available to it. Kitten Max has n pairs of non-negative integers (ai, bi) (1 ≤ i ≤ n), and kitten Min has m pairs of non-negative integers (cj, dj) (1 ≤ j ≤ m). As kitten Max makes a move, it can take any available pair (ai, bi) and add ai to x and bi to y, and kitten Min can take any available pair (cj, dj) and subtract cj from x and dj from y. Each kitten can use each pair multiple times during distinct moves.
Max moves first. Kitten Min is winning if at some moment both numbers a, b are negative simultaneously. Otherwise, the winner of the game is kitten Max. Determine which kitten wins if both of them play optimally.
Input
The first line contains two integers, n and m (1 ≤ n, m ≤ 100 000) — the number of pairs of numbers available to Max and Min, correspondingly.
The second line contains two integers x, y (1 ≤ x, y ≤ 109) — the initial values of numbers with which the kittens are playing.
Next n lines contain the pairs of numbers ai, bi (1 ≤ ai, bi ≤ 109) — the pairs available to Max.
The last m lines contain pairs of numbers cj, dj (1 ≤ cj, dj ≤ 109) — the pairs available to Min.
Output
Print «Max» (without the quotes), if kitten Max wins, or "Min" (without the quotes), if kitten Min wins.
Examples
Input
2 2
42 43
2 3
3 2
3 10
10 3
Output
Min
Input
1 1
1 1
3 4
1 1
Output
Max
Note
In the first test from the statement Min can respond to move (2, 3) by move (3, 10), and to move (3, 2) by move (10, 3). Thus, for each pair of Max and Min's moves the values of both numbers x and y will strictly decrease, ergo, Min will win sooner or later.
In the second sample test after each pair of Max and Min's moves both numbers x and y only increase, thus none of them will become negative.
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > a;
vector<pair<int, int> > v, w;
bool f(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
return 1LL * (-c.second + a.second) * (b.first - a.first) >
1LL * (-b.second + a.second) * (c.first - a.first);
}
int main() {
int n, m, x, y;
scanf("%d%d%d%d", &n, &m, &x, &y);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x, &y);
a.insert(pair<int, int>(x, -y));
v.push_back(pair<int, int>(x, -y));
}
for (int i = 0; i < m; ++i) {
scanf("%d%d", &x, &y);
v.push_back(pair<int, int>(x, -y));
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (pair<int, int> t : v) {
while (w.size() && w.back().second > t.second) w.pop_back();
while (w.size() > 1 && f(w[w.size() - 2], w.back(), t)) w.pop_back();
w.push_back(t);
}
string ans = "Min";
for (pair<int, int> t : w)
if (a.count(t)) {
ans = "Max";
break;
}
puts(ans.c_str());
return 0;
}
|
Duff is in love with lovely numbers! A positive integer x is called lovely if and only if there is no such positive integer a > 1 such that a2 is a divisor of x.
<image>
Malek has a number store! In his store, he has only divisors of positive integer n (and he has all of them). As a birthday present, Malek wants to give her a lovely number from his store. He wants this number to be as big as possible.
Malek always had issues in math, so he asked for your help. Please tell him what is the biggest lovely number in his store.
Input
The first and only line of input contains one integer, n (1 ≤ n ≤ 1012).
Output
Print the answer in one line.
Examples
Input
10
Output
10
Input
12
Output
6
Note
In first sample case, there are numbers 1, 2, 5 and 10 in the shop. 10 isn't divisible by any perfect square, so 10 is lovely.
In second sample case, there are numbers 1, 2, 3, 4, 6 and 12 in the shop. 12 is divisible by 4 = 22, so 12 is not lovely, while 6 is indeed lovely.
|
import math
#n,k = map(int, input().strip().split(' '))
n=int(input())
#lst = list(map(int, input().strip().split(' ')))
if n==1 or n==2 or n==3:
print(n)
else:
p=math.sqrt(n)
l=[1,n]
c=1
for j in range(2,int(p)+1):
if n%j==0:
l.insert(c,j)
if n//j!=j:
l.insert(c+1,n//j)
c+=1
while(True):
if l[-1]%(j*j)==0:
del l[-1]
else:
break
i1=1
i2=-1
while(i1<len(l)):
if l[i1]==l[-1]:
break
else:
if l[i2]%l[i1]**2==0:
del l[i2]
else:
if l[i2]<l[i1]**2:
i1+=1
i2=-1
else:
i2-=1
print(l[-1])
|
Misha decided to help Pasha and Akim be friends again. He had a cunning plan — to destroy all the laughy mushrooms. He knows that the laughy mushrooms can easily burst when they laugh. Mushrooms grow on the lawns. There are a[t] mushrooms on the t-th lawn.
Misha knows that the lawns where the mushrooms grow have a unique ability. A lawn (say, i) can transfer laugh to other lawn (say, j) if there exists an integer (say, b) such, that some permutation of numbers a[i], a[j] and b is a beautiful triple (i ≠ j). A beautiful triple is such three pairwise coprime numbers x, y, z, which satisfy the following condition: x2 + y2 = z2.
Misha wants to know on which minimal number of lawns he should laugh for all the laughy mushrooms to burst.
Input
The first line contains one integer n (1 ≤ n ≤ 106) which is the number of lawns. The next line contains n integers ai which are the number of mushrooms on the i-lawn (1 ≤ ai ≤ 107). All the numbers are different.
Output
Print a single number — the minimal number of lawns on which Misha should laugh for all the mushrooms to burst.
Examples
Input
1
2
Output
1
Input
2
1 2
Output
2
Input
2
3 5
Output
1
|
import java.io.IOException;
import java.util.Arrays;
import java.io.FilterInputStream;
import java.util.HashMap;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.TreeSet;
import java.io.BufferedInputStream;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author Zyflair Griffane
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputUtil in = new InputUtil(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Task solver = new Task();
solver.solve(1, in, out);
out.close();
}
}
class Task {
final int MAX = 10_000_000;
// The main solution method
public void solve(int testNumber, InputUtil in, PrintWriter out) {
int n = in.nextInt();
int[] arr = in.nextIntArray(n);
boolean[] set = new boolean[MAX + 1];
for (int i : arr) set[i]= true;
DisjointSet ds = unionTriplets(IntArrayUtil.max(arr), set);
int res = 0;
for (int i: arr) {
if (set[ds.find(i)]) {
set[ds.find(i)] = false;
res++;
}
}
out.println(res);
}
public DisjointSet unionTriplets(int max, boolean[] set) {
DisjointSet ds = new DisjointSet(max + 1);
long yMax = (long) Math.sqrt(max / 2.0);
for (long y = 1; y <= yMax; y++) {
for (long x = y + 1; (x * y << 1) <= max || (x * x + y * y) <= max; x += 2) {
long u = x * x - y * y;
long v = x * y << 1;
long w = x * x + y * y;
if (gcd(x, y) > 1) {
continue;
}
// System.out.println("BWAH " + u + " " + v + " " + w + " " + set + " " + max);
if (v <= max && set[(int) v]) {
// System.out.println("AND... ");
if (u <= max && set[(int) u]) {
// System.out.print("YES!");
ds.union((int) u, (int) v);
}
if (w <= max && set[(int) w]) {
ds.union((int) v, (int) w);
}
}
if (u <= max && w <= max && set[(int) w] && set[(int) u]) {
ds.union((int) u, (int) w);
}
}
}
return ds;
}
public long gcd(long x, long y) {
return y == 0 ? x : gcd(y, x % y);
}
}
class InputUtil {
JoltyScanner in;
public InputUtil(InputStream istream) {
in = new JoltyScanner(istream);
}
public String next() {
return in.next();
}
public int nextInt() {
return Integer.parseInt(next());
}
public int[] nextIntArray (int size) {
int[] arr = new int[size];
for (int i = 0; i < size; i++) {
arr[i] = in.nextInt();
}
return arr;
}
}
class DisjointSet {
public int[] par;
public int[] rank;
// public int[] size;
public int sets;
public DisjointSet(int n) {
sets = n;
par = new int[n];
rank = new int[n];
// size = new int[n];
// Arrays.fill(size, 1);
for (int i = 0; i < n; i++) {
par[i] = i;
}
}
public void union(int u, int v) {
if (find(u) == find(v)) return;
sets --;
if (rank[find(u)] < rank[find(v)]) {
int t = u;
u = v;
v = t;
}
// size[find(u)] += size[find(v)];
// size[find(v)] = 0;
par[find(v)] = find(u);
rank[find(u)] = Math.max(rank[find(u)], rank[find(v)] + 1);
}
// public int size(int u) {
// return size[find(u)];
// }
public int find(int u) {
if (par[u] == u) {
return u;
}
else {
par[u] = find(par[u]);
return par[u];
}
}
}
class IntArrayUtil {
public static int max(int[] arr) {
if (arr.length == 0) {
throw new RuntimeException("Passed in array has length of 0");
}
int max = arr[0];
for (int a: arr) {
if (a > max) {
max = a;
}
}
return max;
}
}
class JoltyScanner {
public static final int BUFFER_SIZE = 1 << 16;
public static final char NULL_CHAR = (char) -1;
StringBuilder str = new StringBuilder();
byte[] buffer = new byte[BUFFER_SIZE];
boolean EOF_FLAG = false;
int bufferIdx = 0, size = 0;
char c = NULL_CHAR;
BufferedInputStream in;
public JoltyScanner(InputStream in) {
this.in = new BufferedInputStream(in, BUFFER_SIZE);
}
public int nextInt() {
long x = nextLong();
if (x > Integer.MAX_VALUE || x < Integer.MIN_VALUE) {
throw new ArithmeticException("Scanned value overflows integer");
}
return (int) x;
}
public long nextLong() {
boolean negative = false;
if (c == NULL_CHAR) {
c = nextChar();
}
for (; !EOF_FLAG && (c < '0' || c > '9'); c = nextChar()) {
if (c == '-') {
negative = true;
}
}
checkEOF();
long res = 0;
for (; c >= '0' && c <= '9'; c = nextChar()) {
res = (res << 3) + (res << 1) + c - '0';
}
return negative ? -res : res;
}
public String next() {
checkEOF();
if (c == NULL_CHAR) {
c = nextChar();
}
while (Character.isWhitespace(c)) {
c = nextChar();
checkEOF();
}
str.setLength(0);
for (; !EOF_FLAG && !Character.isWhitespace(c); c = nextChar()) {
str.append(c);
}
return str.toString();
}
public char nextChar() {
if (EOF_FLAG) {
return NULL_CHAR;
}
while (bufferIdx == size) {
try {
size = in.read(buffer);
if (size == -1) {
throw new Exception();
}
} catch (Exception e) {
EOF_FLAG = true;
return NULL_CHAR;
}
if (size == -1) {
size = BUFFER_SIZE;
}
bufferIdx = 0;
}
return (char) buffer[bufferIdx++];
}
public void checkEOF() {
if (EOF_FLAG) {
throw new EndOfFileException();
}
}
public class EndOfFileException extends RuntimeException {
}
}
|
To quickly hire highly skilled specialists one of the new IT City companies made an unprecedented move. Every employee was granted a car, and an employee can choose one of four different car makes.
The parking lot before the office consists of one line of (2n - 2) parking spaces. Unfortunately the total number of cars is greater than the parking lot capacity. Furthermore even amount of cars of each make is greater than the amount of parking spaces! That's why there are no free spaces on the parking lot ever.
Looking on the straight line of cars the company CEO thought that parking lot would be more beautiful if it contained exactly n successive cars of the same make. Help the CEO determine the number of ways to fill the parking lot this way.
Input
The only line of the input contains one integer n (3 ≤ n ≤ 30) — the amount of successive cars of the same make.
Output
Output one integer — the number of ways to fill the parking lot by cars of four makes using the described way.
Examples
Input
3
Output
24
Note
Let's denote car makes in the following way: A — Aston Martin, B — Bentley, M — Mercedes-Maybach, Z — Zaporozhets. For n = 3 there are the following appropriate ways to fill the parking lot: AAAB AAAM AAAZ ABBB AMMM AZZZ BBBA BBBM BBBZ BAAA BMMM BZZZ MMMA MMMB MMMZ MAAA MBBB MZZZ ZZZA ZZZB ZZZM ZAAA ZBBB ZMMM
Originally it was planned to grant sport cars of Ferrari, Lamborghini, Maserati and Bugatti makes but this idea was renounced because it is impossible to drive these cars having small road clearance on the worn-down roads of IT City.
|
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.Vector;
public class Main {
public static void main(String[] args) throws IOException{
FastScanner sc = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int n =sc.nextInt();
long ans =(long) ((long) (2*4*3*Math.pow(4, Math.max(0, n-3)))+(n-3)*4*9*Math.pow(4, Math.max(n-4, 0)));
System.out.println(ans);
}
static void generate(int[] p, int L, int R) {
if (L == R) {
}else {
for (int i = L; i <= R; i++) {
int tmp = p[L]; p[L] = p[i]; p[i] = tmp;//swap
generate(p, L+1, R);//recurse
tmp = p[L]; p[L] = p[i]; p[i] = tmp;//unswap
}
}
}
}
class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public FastScanner(String s) {
try {
br = new BufferedReader(new FileReader(s));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
String nextToken() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(nextToken());
}
long nextLong() {
return Long.parseLong(nextToken());
}
double nextDouble() {
return Double.parseDouble(nextToken());
}
}
|
Vasya lives in a round building, whose entrances are numbered sequentially by integers from 1 to n. Entrance n and entrance 1 are adjacent.
Today Vasya got bored and decided to take a walk in the yard. Vasya lives in entrance a and he decided that during his walk he will move around the house b entrances in the direction of increasing numbers (in this order entrance n should be followed by entrance 1). The negative value of b corresponds to moving |b| entrances in the order of decreasing numbers (in this order entrance 1 is followed by entrance n). If b = 0, then Vasya prefers to walk beside his entrance.
<image> Illustration for n = 6, a = 2, b = - 5.
Help Vasya to determine the number of the entrance, near which he will be at the end of his walk.
Input
The single line of the input contains three space-separated integers n, a and b (1 ≤ n ≤ 100, 1 ≤ a ≤ n, - 100 ≤ b ≤ 100) — the number of entrances at Vasya's place, the number of his entrance and the length of his walk, respectively.
Output
Print a single integer k (1 ≤ k ≤ n) — the number of the entrance where Vasya will be at the end of his walk.
Examples
Input
6 2 -5
Output
3
Input
5 1 3
Output
4
Input
3 2 7
Output
3
Note
The first example is illustrated by the picture in the statements.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int n, a, b;
cin >> n >> a >> b;
cout << 1 + (((n * 500) + a + b - 1) % n);
return 0;
}
|
Petya has recently learned data structure named "Binary heap".
The heap he is now operating with allows the following operations:
* put the given number into the heap;
* get the value of the minimum element in the heap;
* extract the minimum element from the heap;
Thus, at any moment of time the heap contains several integers (possibly none), some of them might be equal.
In order to better learn this data structure Petya took an empty heap and applied some operations above to it. Also, he carefully wrote down all the operations and their results to his event log, following the format:
* insert x — put the element with value x in the heap;
* getMin x — the value of the minimum element contained in the heap was equal to x;
* removeMin — the minimum element was extracted from the heap (only one instance, if there were many).
All the operations were correct, i.e. there was at least one element in the heap each time getMin or removeMin operations were applied.
While Petya was away for a lunch, his little brother Vova came to the room, took away some of the pages from Petya's log and used them to make paper boats.
Now Vova is worried, if he made Petya's sequence of operations inconsistent. For example, if one apply operations one-by-one in the order they are written in the event log, results of getMin operations might differ from the results recorded by Petya, and some of getMin or removeMin operations may be incorrect, as the heap is empty at the moment they are applied.
Now Vova wants to add some new operation records to the event log in order to make the resulting sequence of operations correct. That is, the result of each getMin operation is equal to the result in the record, and the heap is non-empty when getMin ad removeMin are applied. Vova wants to complete this as fast as possible, as the Petya may get back at any moment. He asks you to add the least possible number of operation records to the current log. Note that arbitrary number of operations may be added at the beginning, between any two other operations, or at the end of the log.
Input
The first line of the input contains the only integer n (1 ≤ n ≤ 100 000) — the number of the records left in Petya's journal.
Each of the following n lines describe the records in the current log in the order they are applied. Format described in the statement is used. All numbers in the input are integers not exceeding 109 by their absolute value.
Output
The first line of the output should contain a single integer m — the minimum possible number of records in the modified sequence of operations.
Next m lines should contain the corrected sequence of records following the format of the input (described in the statement), one per line and in the order they are applied. All the numbers in the output should be integers not exceeding 109 by their absolute value.
Note that the input sequence of operations must be the subsequence of the output sequence.
It's guaranteed that there exists the correct answer consisting of no more than 1 000 000 operations.
Examples
Input
2
insert 3
getMin 4
Output
4
insert 3
removeMin
insert 4
getMin 4
Input
4
insert 1
insert 1
removeMin
getMin 2
Output
6
insert 1
insert 1
removeMin
removeMin
insert 2
getMin 2
Note
In the first sample, after number 3 is inserted into the heap, the minimum number is 3. To make the result of the first getMin equal to 4 one should firstly remove number 3 from the heap and then add number 4 into the heap.
In the second sample case number 1 is inserted two times, so should be similarly removed twice.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
public class C357 {
public static void main(String[] args) {
MyScanner scan = new MyScanner();
PrintWriter out = new PrintWriter(System.out);
int N = scan.nextInt();
PriorityQueue<Integer> q = new PriorityQueue<>();
ArrayList<Op> list = new ArrayList<>();
for(int i=0;i<N;i++){
String s = scan.next();
if(s.equals("insert")){
int t = scan.nextInt();
q.add(t);
list.add(new Op(0, t, i));
}
if(s.equals("getMin")){
int t = scan.nextInt();
if(q.isEmpty()||!q.peek().equals(t)){
while(!q.isEmpty()&&q.peek().compareTo(t)<0){
q.poll();
list.add(new Op(1, -1,-1));
}
if(q.isEmpty()||q.peek().compareTo(t)>0){
q.add(t);
list.add(new Op(0, t, i));
}
}
list.add(new Op(2, t, i));
}
if(s.equals("removeMin")){
if(q.size()==0){
list.add(new Op(0, 1, -1));
}
list.add(new Op(1, -1,-1));
q.poll();
}
}
out.println(list.size());
for(int i=0;i<list.size();i++){
if(list.get(i).type==0){
out.println("insert "+list.get(i).val);
}
if(list.get(i).type==1){
out.println("removeMin");
}
if(list.get(i).type==2){
out.println("getMin "+list.get(i).val);
}
}
out.close();
}
private static class Op {
int type, val, idx;
//0 = insert, 1 = remove, 2 = getMin
public Op(int type, int val, int idx){
this.type = type;
this.val = val;
this.idx = idx;
}
}
private static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {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());}
}
}
|
Scott Lang is at war with Darren Cross. There are n chairs in a hall where they are, numbered with 1, 2, ..., n from left to right. The i-th chair is located at coordinate xi. Scott is on chair number s and Cross is on chair number e. Scott can jump to all other chairs (not only neighboring chairs). He wants to start at his position (chair number s), visit each chair exactly once and end up on chair number e with Cross.
As we all know, Scott can shrink or grow big (grow big only to his normal size), so at any moment of time he can be either small or large (normal). The thing is, he can only shrink or grow big while being on a chair (not in the air while jumping to another chair). Jumping takes time, but shrinking and growing big takes no time. Jumping from chair number i to chair number j takes |xi - xj| seconds. Also, jumping off a chair and landing on a chair takes extra amount of time.
If Scott wants to jump to a chair on his left, he can only be small, and if he wants to jump to a chair on his right he should be large.
Jumping off the i-th chair takes:
* ci extra seconds if he's small.
* di extra seconds otherwise (he's large).
Also, landing on i-th chair takes:
* bi extra seconds if he's small.
* ai extra seconds otherwise (he's large).
In simpler words, jumping from i-th chair to j-th chair takes exactly:
* |xi - xj| + ci + bj seconds if j < i.
* |xi - xj| + di + aj seconds otherwise (j > i).
Given values of x, a, b, c, d find the minimum time Scott can get to Cross, assuming he wants to visit each chair exactly once.
Input
The first line of the input contains three integers n, s and e (2 ≤ n ≤ 5000, 1 ≤ s, e ≤ n, s ≠ e) — the total number of chairs, starting and ending positions of Scott.
The second line contains n integers x1, x2, ..., xn (1 ≤ x1 < x2 < ... < xn ≤ 109).
The third line contains n integers a1, a2, ..., an (1 ≤ a1, a2, ..., an ≤ 109).
The fourth line contains n integers b1, b2, ..., bn (1 ≤ b1, b2, ..., bn ≤ 109).
The fifth line contains n integers c1, c2, ..., cn (1 ≤ c1, c2, ..., cn ≤ 109).
The sixth line contains n integers d1, d2, ..., dn (1 ≤ d1, d2, ..., dn ≤ 109).
Output
Print the minimum amount of time Scott needs to get to the Cross while visiting each chair exactly once.
Example
Input
7 4 3
8 11 12 16 17 18 20
17 16 20 2 20 5 13
17 8 8 16 12 15 13
12 4 16 4 15 7 6
8 14 2 11 17 12 8
Output
139
Note
In the sample testcase, an optimal solution would be <image>. Spent time would be 17 + 24 + 23 + 20 + 33 + 22 = 139.
|
#include <bits/stdc++.h>
long long f[5010][5010];
int a[5010], b[5010], c[5010], d[5010], x[5010];
int main() {
int n, s, e;
scanf("%d%d%d", &n, &s, &e);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] += x[i];
for (int i = 1; i <= n; i++) scanf("%d", &b[i]), b[i] -= x[i];
for (int i = 1; i <= n; i++) scanf("%d", &c[i]), c[i] += x[i];
for (int i = 1; i <= n; i++) scanf("%d", &d[i]), d[i] -= x[i];
memset(f, 0x3f, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++) {
if (s >= i || e >= i || j > 2)
f[i][j] = std::min(f[i][j], f[i - 1][j - 1] + (i != s ? b[i] : 0) +
(i != e ? d[i] : 0));
if (i != e && (s >= i || j > 1))
f[i][j] = std::min(f[i][j], f[i - 1][j] + c[i] + (i != s ? b[i] : 0));
if (i != s && (e >= i || j > 1))
f[i][j] = std::min(f[i][j], f[i - 1][j] + a[i] + (i != e ? d[i] : 0));
if (i != e && i != s)
f[i][j] = std::min(f[i][j], f[i - 1][j + 1] + a[i] + c[i]);
}
printf("%lld\n", f[n][1]);
}
|
Alice and Bob are well-known for sending messages to each other. This time you have a rooted tree with Bob standing in the root node and copies of Alice standing in each of the other vertices. The root node has number 0, the rest are numbered 1 through n.
At some moments of time some copies of Alice want to send a message to Bob and receive an answer. We will call this copy the initiator. The process of sending a message contains several steps:
* The initiator sends the message to the person standing in the parent node and begins waiting for the answer.
* When some copy of Alice receives a message from some of her children nodes, she sends the message to the person standing in the parent node and begins waiting for the answer.
* When Bob receives a message from some of his child nodes, he immediately sends the answer to the child node where the message came from.
* When some copy of Alice (except for initiator) receives an answer she is waiting for, she immediately sends it to the child vertex where the message came from.
* When the initiator receives the answer she is waiting for, she doesn't send it to anybody.
* There is a special case: a copy of Alice can't wait for two answers at the same time, so if some copy of Alice receives a message from her child node while she already waits for some answer, she rejects the message and sends a message saying this back to the child node where the message came from. Then the copy of Alice in the child vertex processes this answer as if it was from Bob.
* The process of sending a message to a parent node or to a child node is instant but a receiver (a parent or a child) gets a message after 1 second.
If some copy of Alice receives several messages from child nodes at the same moment while she isn't waiting for an answer, she processes the message from the initiator with the smallest number and rejects all the rest. If some copy of Alice receives messages from children nodes and also receives the answer she is waiting for at the same instant, then Alice first processes the answer, then immediately continue as normal with the incoming messages.
You are given the moments of time when some copy of Alice becomes the initiator and sends a message to Bob. For each message, find the moment of time when the answer (either from Bob or some copy of Alice) will be received by the initiator.
You can assume that if Alice wants to send a message (i.e. become the initiator) while waiting for some answer, she immediately rejects the message and receives an answer from herself in no time.
Input
The first line of input contains two integers n and m (1 ≤ n, m ≤ 200 000) — the number of nodes with Alices and the number of messages.
Second line contains n integers p1, p2, ..., pn (0 ≤ pi < i). The integer pi is the number of the parent node of node i.
The next m lines describe the messages. The i-th of them contains two integers xi and ti (1 ≤ xi ≤ n, 1 ≤ ti ≤ 109) — the number of the vertex of the initiator of the i-th message and the time of the initiation (in seconds). The messages are given in order of increasing initiation time (i.e. ti + 1 ≥ ti holds for 1 ≤ i < m). The pairs (xi, ti) are distinct.
Output
Print m integers — the i-th of them is the moment of time when the answer for the i-th message will be received by the initiator.
Examples
Input
6 3
0 1 2 3 2 5
4 6
6 9
5 11
Output
14 13 11
Input
3 2
0 1 1
2 1
3 1
Output
5 3
Input
8 3
0 1 1 2 3 3 4 5
6 1
8 2
4 5
Output
7 6 11
Note
In the first example the first message is initiated at the moment 6, reaches Bob at the moment 10, and the answer reaches the initiator at the moment 14. The second message reaches vertex 2 at the moment 11. At this moment the copy of Alice in this vertex is still waiting for the answer for the first message, so she rejects the second message. The answer reaches the initiator at the moment 13. The third message is not sent at all, because at the moment 11 Alice in vertex 5 is waiting for the answer for the second message.
In the second example the first message reaches Bob, the second is rejected by Alice in vertex 1. This is because the message with smaller initiator number has the priority.
In the third example the first and the third messages reach Bob, while the second message is rejected by Alice in vertex 3.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 8e5 + 5;
const int inf = 1 << 28;
vector<int> adj[maxn];
int siz[maxn], top[maxn], par[maxn], mson[maxn];
int ans[maxn], n, m, ord[maxn], x[maxn], t[maxn];
int dfn[maxn], edfn[maxn], idx, pos[maxn], dep[maxn];
int maxd[maxn], rst[maxn], eff[maxn];
void build(int rt, int L, int R) {
rst[rt] = eff[rt] = -inf;
if (L >= R) {
maxd[rt] = dep[pos[L]];
return;
}
int mid = L + R >> 1;
build(rt << 1, L, mid);
build(rt << 1 | 1, mid + 1, R);
maxd[rt] = max(maxd[rt << 1], maxd[rt << 1 | 1]);
}
void effect(int rt, int val) {
eff[rt] = max(eff[rt], val);
rst[rt] = max(rst[rt], maxd[rt] * 2 + val);
}
void pushdown(int rt) {
effect(rt << 1, eff[rt]);
effect(rt << 1 | 1, eff[rt]);
}
void modify(int rt, int L, int R, int l, int r, int val) {
if (L >= l && R <= r) {
effect(rt, val);
return;
}
int mid = L + R >> 1;
pushdown(rt);
if (l <= mid) modify(rt << 1, L, mid, l, r, val);
if (r > mid) modify(rt << 1 | 1, mid + 1, R, l, r, val);
rst[rt] = max(rst[rt << 1], rst[rt << 1 | 1]);
}
int query(int rt, int L, int R, int l, int r, int val) {
if (rst[rt] <= val) return 0;
if (L >= R) return pos[L];
int mid = L + R >> 1;
pushdown(rt);
if (r > mid) {
int res = query(rt << 1 | 1, mid + 1, R, l, r, val);
if (res) return res;
}
if (l <= mid) {
int res = query(rt << 1, L, mid, l, r, val);
if (res) return res;
}
return 0;
}
void dfs1(int u) {
siz[u] = 1;
for (auto v : adj[u])
if (v != par[u]) {
par[v] = u;
dep[v] = dep[u] + 1;
dfs1(v);
siz[u] += siz[v];
siz[v] > siz[mson[u]] ? mson[u] = v : 0;
}
}
void dfs2(int u, int tp) {
dfn[u] = edfn[n] = ++idx;
pos[idx] = u;
top[u] = tp;
if (mson[u]) dfs2(mson[u], tp);
for (auto v : adj[u])
if (v != par[u] && v != mson[u]) dfs2(v, v);
edfn[u] = idx;
}
void modify(int u, int t, int val) {
while (top[u] != top[t]) {
modify(1, 1, n, dfn[top[u]], dfn[u], val);
u = par[top[u]];
}
modify(1, 1, n, dfn[t], dfn[u], val);
}
int solve(int u, int val) {
while (top[u] != 1) {
int res = query(1, 1, n, dfn[top[u]], dfn[u], val);
if (res) return res;
u = par[top[u]];
}
int res = query(1, 1, n, 1, dfn[u], val);
return res ? res : 1;
}
bool cmp(int a, int b) {
int ta = dep[x[a]] + t[a];
int tb = dep[x[b]] + t[b];
return ta != tb ? ta < tb : x[a] < x[b];
}
int main() {
scanf("%d %d", &n, &m);
++n;
for (int v, i = 2; i <= n; i++) scanf("%d", &v), adj[v + 1].push_back(i);
dfs1(1);
dfs2(1, 1);
build(1, 1, n);
for (int i = 1; i <= (m); i++) scanf("%d %d", &x[i], &t[i]);
for (int i = 1; i <= (m); i++) ord[i] = i, x[i]++;
sort(ord + 1, ord + m + 1, cmp);
for (int i = 1; i <= (m); i++) {
int o = ord[i], top = solve(x[o], t[o] + dep[x[o]]);
ans[o] = t[o] + 2 * (dep[x[o]] - dep[top]);
modify(x[o], top, ans[o] - dep[x[o]]);
}
for (int i = 1; i <= (m); i++) printf("%d ", ans[i]);
return 0;
}
|
Santa Claus is the first who came to the Christmas Olympiad, and he is going to be the first to take his place at a desk! In the classroom there are n lanes of m desks each, and there are two working places at each of the desks. The lanes are numbered from 1 to n from the left to the right, the desks in a lane are numbered from 1 to m starting from the blackboard. Note that the lanes go perpendicularly to the blackboard, not along it (see picture).
The organizers numbered all the working places from 1 to 2nm. The places are numbered by lanes (i. e. all the places of the first lane go first, then all the places of the second lane, and so on), in a lane the places are numbered starting from the nearest to the blackboard (i. e. from the first desk in the lane), at each desk, the place on the left is numbered before the place on the right.
<image> The picture illustrates the first and the second samples.
Santa Clause knows that his place has number k. Help him to determine at which lane at which desk he should sit, and whether his place is on the left or on the right!
Input
The only line contains three integers n, m and k (1 ≤ n, m ≤ 10 000, 1 ≤ k ≤ 2nm) — the number of lanes, the number of desks in each lane and the number of Santa Claus' place.
Output
Print two integers: the number of lane r, the number of desk d, and a character s, which stands for the side of the desk Santa Claus. The character s should be "L", if Santa Clause should sit on the left, and "R" if his place is on the right.
Examples
Input
4 3 9
Output
2 2 L
Input
4 3 24
Output
4 3 R
Input
2 4 4
Output
1 2 R
Note
The first and the second samples are shown on the picture. The green place corresponds to Santa Claus' place in the first example, the blue place corresponds to Santa Claus' place in the second example.
In the third sample there are two lanes with four desks in each, and Santa Claus has the fourth place. Thus, his place is in the first lane at the second desk on the right.
|
#include <bits/stdc++.h>
using namespace std;
bool s_end(size_t c) { return (c == string ::npos) ? true : false; }
int main() {
int n, m, k;
cin >> n >> m >> k;
int lane = (k + 2 * m - 1) / (2 * m);
k -= (lane - 1) * 2 * m;
int desk = (k + 1) / 2;
char side = (k % 2) ? 'L' : 'R';
cout << lane << " " << desk << " " << side;
return 0;
}
|
A sequence of square brackets is regular if by inserting symbols "+" and "1" into it, you can get a regular mathematical expression from it. For example, sequences "[[]][]", "[]" and "[[][[]]]" — are regular, at the same time "][", "[[]" and "[[]]][" — are irregular.
Draw the given sequence using a minimalistic pseudographics in the strip of the lowest possible height — use symbols '+', '-' and '|'. For example, the sequence "[[][]][]" should be represented as:
+- -++- -+
|+- -++- -+|| |
|| || ||| |
|+- -++- -+|| |
+- -++- -+
Each bracket should be represented with the hepl of one or more symbols '|' (the vertical part) and symbols '+' and '-' as on the example which is given above.
Brackets should be drawn without spaces one by one, only dividing pairs of consecutive pairwise brackets with a single-space bar (so that the two brackets do not visually merge into one symbol). The image should have the minimum possible height.
The enclosed bracket is always smaller than the surrounding bracket, but each bracket separately strives to maximize the height of the image. So the pair of final brackets in the example above occupies the entire height of the image.
Study carefully the examples below, they adequately explain the condition of the problem. Pay attention that in this problem the answer (the image) is unique.
Input
The first line contains an even integer n (2 ≤ n ≤ 100) — the length of the sequence of brackets.
The second line contains the sequence of brackets — these are n symbols "[" and "]". It is guaranteed that the given sequence of brackets is regular.
Output
Print the drawn bracket sequence in the format which is given in the condition. Don't print extra (unnecessary) spaces.
Examples
Input
8
[[][]][]
Output
+- -++- -+
|+- -++- -+|| |
|| || ||| |
|+- -++- -+|| |
+- -++- -+
Input
6
[[[]]]
Output
+- -+
|+- -+|
||+- -+||
||| |||
||+- -+||
|+- -+|
+- -+
Input
6
[[][]]
Output
+- -+
|+- -++- -+|
|| || ||
|+- -++- -+|
+- -+
Input
2
[]
Output
+- -+
| |
+- -+
Input
4
[][]
Output
+- -++- -+
| || |
+- -++- -+
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout.setf(ios_base::fixed);
cout.precision(24);
int n;
cin >> n;
vector<int> deep(n, 0);
string s;
cin >> s;
int cnt = 0, mx = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == '[') {
deep[i] = cnt;
cnt++;
} else {
cnt--;
deep[i] = cnt;
}
mx = max(mx, deep[i]);
}
int sz = (1 + mx) * 2 + 1;
int j = 0;
vector<string> table(sz, string(10 * n, ' '));
for (int i = 0; i < n; ++i) {
int t = mx - deep[i];
int cnt = (t)*2 + 1;
if (s[i] == '[') {
table[deep[i]][j] = '+';
table[deep[i]][j + 1] = '-';
for (int k = deep[i] + 1, tt = 0; tt < cnt; ++tt, ++k) {
table[k][j] = '|';
}
table[deep[i] + cnt + 1][j + 1] = '-';
table[deep[i] + cnt + 1][j] = '+';
j++;
} else {
table[deep[i]][j] = '-';
table[deep[i]][j + 1] = '+';
for (int k = deep[i] + 1, tt = 0; tt < cnt; ++tt, ++k) {
table[k][j + 1] = '|';
}
table[deep[i] + cnt + 1][j + 1] = '+';
table[deep[i] + cnt + 1][j] = '-';
j += 2;
if (i + 1 != n) {
if (s[i + 1] == ']') {
j--;
}
}
}
if (s[i] == '[' && deep[i] == deep[i + 1]) {
j += 2;
}
}
bool ok = true;
while (ok) {
for (int i = 0; i < sz; ++i) {
table[i].pop_back();
}
for (int i = 0; i < sz; ++i) {
if (table[i].back() != ' ') {
ok = false;
break;
}
}
}
for (auto p : table) {
cout << p << "\n";
}
return 0;
}
|
Igor the analyst is at work. He learned about a feature in his text editor called "Replace All". Igor is too bored at work and thus he came up with the following problem:
Given two strings x and y which consist of the English letters 'A' and 'B' only, a pair of strings (s, t) is called good if:
* s and t consist of the characters '0' and '1' only.
* 1 ≤ |s|, |t| ≤ n, where |z| denotes the length of string z, and n is a fixed positive integer.
* If we replace all occurrences of 'A' in x and y with the string s, and replace all occurrences of 'B' in x and y with the string t, then the two obtained from x and y strings are equal.
For example, if x = AAB, y = BB and n = 4, then (01, 0101) is one of good pairs of strings, because both obtained after replacing strings are "01010101".
The flexibility of a pair of strings x and y is the number of pairs of good strings (s, t). The pairs are ordered, for example the pairs (0, 1) and (1, 0) are different.
You're given two strings c and d. They consist of characters 'A', 'B' and '?' only. Find the sum of flexibilities of all possible pairs of strings (c', d') such that c' and d' can be obtained from c and d respectively by replacing the question marks with either 'A' or 'B', modulo 109 + 7.
Input
The first line contains the string c (1 ≤ |c| ≤ 3·105).
The second line contains the string d (1 ≤ |d| ≤ 3·105).
The last line contains a single integer n (1 ≤ n ≤ 3·105).
Output
Output a single integer: the answer to the problem, modulo 109 + 7.
Examples
Input
A?
?
3
Output
2
Input
A
B
10
Output
2046
Note
For the first sample, there are four possible pairs of (c', d').
If (c', d') = (AA, A), then the flexibility is 0.
If (c', d') = (AB, A), then the flexibility is 0.
If (c', d') = (AA, B), then the flexibility is 2, as the pairs of binary strings (1, 11), (0, 00) are the only good pairs.
If (c', d') = (AB, B), then the flexibility is 0.
Thus, the total flexibility is 2.
For the second sample, there are 21 + 22 + ... + 210 = 2046 possible binary strings of length not greater 10, and the set of pairs of good strings is precisely the set of pairs (s, s), where s is a binary string of length not greater than 10.
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskG solver = new TaskG();
solver.solve(1, in, out);
out.close();
}
static class TaskG {
static final long MODULO = (long) (1e9 + 7);
public void solve(int testNumber, InputReader in, PrintWriter out) {
String c = in.next();
String d = in.next();
int n = in.nextInt();
long res = 0;
long waysEqual = 0;
if (c.length() == d.length()) {
waysEqual = 1;
for (int i = 0; i < c.length(); ++i) {
char ac = c.charAt(i);
char ad = d.charAt(i);
if (ac == '?') {
if (ad == '?') {
waysEqual = waysEqual * 2 % MODULO;
}
} else if (ad == '?') {
} else {
if (ac != ad) {
waysEqual = 0;
break;
}
}
}
long total = 1;
for (int i = 0; i < n; ++i) {
total = total * 2 % MODULO;
}
total = ((total * 2 - 2) % MODULO + MODULO) % MODULO;
res = (res + total * total % MODULO * waysEqual) % MODULO;
}
long[] nonperiodic = new long[n + 1];
nonperiodic[0] = 1;
for (int i = 1; i <= n; ++i) nonperiodic[i] = 2 * nonperiodic[i - 1] % MODULO;
long[] uptoValid = new long[n + 1];
for (int i = 1; i <= n; ++i) {
uptoValid[i] = uptoValid[i - 1] + nonperiodic[i];
uptoValid[i] %= MODULO;
}
for (int i = 1; i <= n; ++i) {
for (int j = 2 * i; j <= n; j += i) {
nonperiodic[j] -= nonperiodic[i];
if (nonperiodic[j] < 0) nonperiodic[j] += MODULO;
}
}
long anyValid = 0;
for (int i = 1; i <= n; ++i) {
long maxTimes = n / i;
anyValid = (anyValid + nonperiodic[i] * maxTimes % MODULO * maxTimes) % MODULO;
}
int na = 0;
int nb = 0;
int qPlus = 0;
int qMinus = 0;
for (int i = 0; i < c.length(); ++i) {
char ac = c.charAt(i);
if (ac == 'A') ++na;
else if (ac == 'B') ++nb;
else ++qPlus;
}
for (int i = 0; i < d.length(); ++i) {
char ad = d.charAt(i);
if (ad == 'A') --na;
else if (ad == 'B') --nb;
else ++qMinus;
}
na -= qMinus;
qPlus += qMinus;
qMinus = 0;
long[] invs = new long[qPlus + 1];
if (qPlus > 0)
invs[1] = 1;
for (int i = 2; i <= qPlus; ++i) {
invs[i] = (MODULO - invs[((int) (MODULO % i))] * (MODULO / i) % MODULO) % MODULO;
if (invs[i] * i % MODULO != 1) throw new RuntimeException();
}
long comb = 1;
for (int nPlus = 0; nPlus <= qPlus; ++nPlus) {
if (nPlus > 0) {
comb = comb * (qPlus - nPlus + 1) % MODULO * invs[nPlus] % MODULO;
}
int deltaMul = na + nPlus;
int bMul = c.length() - d.length();
if (deltaMul == 0 && bMul == 0) {
res = ((res + (comb - waysEqual) * anyValid) % MODULO + MODULO) % MODULO;
} else {
int g = gcd(Math.abs(deltaMul), Math.abs(bMul));
deltaMul /= g;
bMul /= g;
if (deltaMul != 0) {
if (deltaMul < 0) {
deltaMul = -deltaMul;
bMul = -bMul;
}
int lb = deltaMul;
int la = lb - bMul;
if (la > 0) {
res = (res + comb * uptoValid[n / Math.max(la, lb)]) % MODULO;
}
}
}
}
out.println(res);
}
private int gcd(int a, int b) {
while (b > 0) {
int t = a % b;
a = b;
b = t;
}
return a;
}
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
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());
}
}
}
|
Karen is getting ready for a new school day!
<image>
It is currently hh:mm, given in a 24-hour format. As you know, Karen loves palindromes, and she believes that it is good luck to wake up when the time is a palindrome.
What is the minimum number of minutes she should sleep, such that, when she wakes up, the time is a palindrome?
Remember that a palindrome is a string that reads the same forwards and backwards. For instance, 05:39 is not a palindrome, because 05:39 backwards is 93:50. On the other hand, 05:50 is a palindrome, because 05:50 backwards is 05:50.
Input
The first and only line of input contains a single string in the format hh:mm (00 ≤ hh ≤ 23, 00 ≤ mm ≤ 59).
Output
Output a single integer on a line by itself, the minimum number of minutes she should sleep, such that, when she wakes up, the time is a palindrome.
Examples
Input
05:39
Output
11
Input
13:31
Output
0
Input
23:59
Output
1
Note
In the first test case, the minimum number of minutes Karen should sleep for is 11. She can wake up at 05:50, when the time is a palindrome.
In the second test case, Karen can wake up immediately, as the current time, 13:31, is already a palindrome.
In the third test case, the minimum number of minutes Karen should sleep for is 1 minute. She can wake up at 00:00, when the time is a palindrome.
|
h, m = map(int, input().split(':'))
for i in range(999):
if h == 10 * (m % 10) + m // 10:
print(i)
break
h, m = (h, m + 1) if m < 59 else ((h + 1) % 24, 0)
|
One day Kefa found n baloons. For convenience, we denote color of i-th baloon as si — lowercase letter of the Latin alphabet. Also Kefa has k friends. Friend will be upset, If he get two baloons of the same color. Kefa want to give out all baloons to his friends. Help Kefa to find out, can he give out all his baloons, such that no one of his friens will be upset — print «YES», if he can, and «NO», otherwise. Note, that Kefa's friend will not upset, if he doesn't get baloons at all.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 100) — the number of baloons and friends.
Next line contains string s — colors of baloons.
Output
Answer to the task — «YES» or «NO» in a single line.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
4 2
aabb
Output
YES
Input
6 3
aacaab
Output
NO
Note
In the first sample Kefa can give 1-st and 3-rd baloon to the first friend, and 2-nd and 4-th to the second.
In the second sample Kefa needs to give to all his friends baloons of color a, but one baloon will stay, thats why answer is «NO».
|
from collections import Counter
n , k = map(int , input().split())
s = input()
s = list(s)
cnt = Counter(s)
r = 0
for i in cnt:
if cnt[i] > k:
r = 1
break
print('YES' if r == 0 else 'NO')
|
Mahmoud and Ehab continue their adventures! As everybody in the evil land knows, Dr. Evil likes bipartite graphs, especially trees.
A tree is a connected acyclic graph. A bipartite graph is a graph, whose vertices can be partitioned into 2 sets in such a way, that for each edge (u, v) that belongs to the graph, u and v belong to different sets. You can find more formal definitions of a tree and a bipartite graph in the notes section below.
Dr. Evil gave Mahmoud and Ehab a tree consisting of n nodes and asked them to add edges to it in such a way, that the graph is still bipartite. Besides, after adding these edges the graph should be simple (doesn't contain loops or multiple edges). What is the maximum number of edges they can add?
A loop is an edge, which connects a node with itself. Graph doesn't contain multiple edges when for each pair of nodes there is no more than one edge between them. A cycle and a loop aren't the same .
Input
The first line of input contains an integer n — the number of nodes in the tree (1 ≤ n ≤ 105).
The next n - 1 lines contain integers u and v (1 ≤ u, v ≤ n, u ≠ v) — the description of the edges of the tree.
It's guaranteed that the given graph is a tree.
Output
Output one integer — the maximum number of edges that Mahmoud and Ehab can add to the tree while fulfilling the conditions.
Examples
Input
3
1 2
1 3
Output
0
Input
5
1 2
2 3
3 4
4 5
Output
2
Note
Tree definition: https://en.wikipedia.org/wiki/Tree_(graph_theory)
Bipartite graph definition: <https://en.wikipedia.org/wiki/Bipartite_graph>
In the first test case the only edge that can be added in such a way, that graph won't contain loops or multiple edges is (2, 3), but adding this edge will make the graph non-bipartite so the answer is 0.
In the second test case Mahmoud and Ehab can add edges (1, 4) and (2, 5).
|
from collections import defaultdict
n = int(input())
degree = [0 for i in range(n+1)]
def BFS(d,x,visited):
visited[x] = 1
queue = [(x,1)]
l1 = set()
l2 = set()
while len(queue):
temp,j = queue.pop()
visited[temp] = 1
if j%2 == 1:
l1.add(temp)
else:
l2.add(temp)
for i in d[temp]:
if visited[i] == 0:
queue.append((i,j+1))
return l1,l2
d = defaultdict(list)
for i in range(n-1):
u,v = map(int,input().split())
d[u].append(v)
d[v].append(u)
degree[u] = degree[u] + 1
degree[v] = degree[v] + 1
visited = [0 for i in range(n+1)]
l1,l2 = BFS(d,1,visited)
s = 0
for i in range(1,n+1):
if i in l1:
s = s + len(l2)-degree[i]
elif i in l2:
s = s + len(l1)-degree[i]
print(s//2)
|
During the final part of fashion show all models come to the stage and stay in one row and fashion designer stays to right to model on the right. During the rehearsal, Izabella noticed, that row isn't nice, but she can't figure out how to fix it.
Like many other creative people, Izabella has a specific sense of beauty. Evaluating beauty of row of models Izabella looks at heights of models. She thinks that row is nice if for each model distance to nearest model with less height (model or fashion designer) to the right of her doesn't exceed k (distance between adjacent people equals 1, the distance between people with exactly one man between them equals 2, etc).
She wants to make row nice, but fashion designer has his own sense of beauty, so she can at most one time select two models from the row and swap their positions if the left model from this pair is higher than the right model from this pair.
Fashion designer (man to the right of rightmost model) has less height than all models and can't be selected for exchange.
You should tell if it's possible to make at most one exchange in such a way that row becomes nice for Izabella.
Input
In first line there are two integers n and k (1 ≤ n ≤ 5·105, 1 ≤ k ≤ n) — number of models and required distance.
Second line contains n space-separated integers ai (1 ≤ ai ≤ 109) — height of each model. Pay attention that height of fashion designer is not given and can be less than 1.
Output
Print «YES» (without quotes) if it's possible to make row nice using at most one exchange, and «NO» (without quotes) otherwise.
Examples
Input
5 4
2 3 5 2 5
Output
NO
Input
5 2
3 6 2 2 1
Output
YES
Input
5 2
5 3 6 5 2
Output
YES
|
#include <bits/stdc++.h>
using namespace std;
int a[500010], n, k, suf[500010];
int l_bad, r_bad;
int mi[500010 << 2], mi_pos[500010 << 2];
vector<int> v[500010];
void push_up(int o) {
mi[o] = min(mi[o << 1], mi[o << 1 | 1]);
mi_pos[o] =
(mi[o << 1] < mi[o << 1 | 1]) ? mi_pos[o << 1] : mi_pos[o << 1 | 1];
}
void build(int l, int r, int o) {
if (l == r) {
mi[o] = a[l], mi_pos[o] = l;
return;
}
int m = (l + r) >> 1;
build(l, m, o << 1), build(m + 1, r, o << 1 | 1);
push_up(o);
}
void update(int l, int r, int o, int pos, int v) {
if (l == r) {
mi[o] = v;
return;
}
int m = (l + r) >> 1;
if (pos <= m)
update(l, m, o << 1, pos, v);
else
update(m + 1, r, o << 1 | 1, pos, v);
push_up(o);
}
pair<int, int> query(int l, int r, int o, int ql, int qr) {
if (ql <= l && r <= qr) return pair<int, int>(mi[o], mi_pos[o]);
int m = (l + r) >> 1;
if (ql > m) return query(m + 1, r, o << 1 | 1, ql, qr);
if (qr <= m) return query(l, m, o << 1, ql, qr);
return min(query(l, m, o << 1, ql, m),
query(m + 1, r, o << 1 | 1, m + 1, qr));
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, n, 1);
for (int i = 1; i <= n - k; i++) {
suf[i] = query(1, n, 1, i + 1, i + k).first;
if (a[i] <= suf[i]) {
if (!l_bad) l_bad = i;
r_bad = i;
}
}
if (!r_bad) return 0 * puts("YES");
if (r_bad + 1 > l_bad + k) return 0 * puts("NO");
if (r_bad + k + 1 > n) return 0 * puts("NO");
for (int i = r_bad + 1; i <= n - k; i++) {
pair<int, int> t = query(1, n, 1, i + 1, i + k);
update(1, n, 1, t.second, 2000000000);
if (a[i] <= query(1, n, 1, i + 1, i + k).first) v[t.second].push_back(i);
update(1, n, 1, t.second, t.first);
}
for (int i = r_bad + k + 1; i <= n; i++)
if (a[i] < a[l_bad]) {
for (int j = r_bad + 1; j <= l_bad + k; j++) {
if (a[i] > suf[j] && (!v[i].size() || v[i].back() < j))
return 0 * puts("YES");
}
}
puts("NO");
return 0;
}
|
A frog lives on the axis Ox and needs to reach home which is in the point n. She starts from the point 1. The frog can jump to the right at a distance not more than d. So, after she jumped from the point x she can reach the point x + a, where a is an integer from 1 to d.
For each point from 1 to n is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and n.
Determine the minimal number of jumps that the frog needs to reach home which is in the point n from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1.
Input
The first line contains two integers n and d (2 ≤ n ≤ 100, 1 ≤ d ≤ n - 1) — the point, which the frog wants to reach, and the maximal length of the frog jump.
The second line contains a string s of length n, consisting of zeros and ones. If a character of the string s equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string s equal to one.
Output
If the frog can not reach the home, print -1.
In the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point n from the point 1.
Examples
Input
8 4
10010101
Output
2
Input
4 2
1001
Output
-1
Input
8 4
11100101
Output
3
Input
12 3
101111100101
Output
4
Note
In the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four).
In the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two.
|
n , d =map(int, input().split())
s= str(input())
ans = -1
i=1
count = 0
while i<len(s):
temp = s[i:i+d]
if '1' in temp:
x = temp.rfind('1')
i = i+ x +1
count = count +1
else:
print(ans)
count=0
break
if count!=0:
print(count)
|
For a permutation P[1... N] of integers from 1 to N, function f is defined as follows:
<image>
Let g(i) be the minimum positive integer j such that f(i, j) = i. We can show such j always exists.
For given N, A, B, find a permutation P of integers from 1 to N such that for 1 ≤ i ≤ N, g(i) equals either A or B.
Input
The only line contains three integers N, A, B (1 ≤ N ≤ 106, 1 ≤ A, B ≤ N).
Output
If no such permutation exists, output -1. Otherwise, output a permutation of integers from 1 to N.
Examples
Input
9 2 5
Output
6 5 8 3 4 1 9 2 7
Input
3 2 1
Output
1 2 3
Note
In the first example, g(1) = g(6) = g(7) = g(9) = 2 and g(2) = g(3) = g(4) = g(5) = g(8) = 5
In the second example, g(1) = g(2) = g(3) = 1
|
#include <bits/stdc++.h>
using namespace std;
void print(int p, int q) {
for (int i = 1; i < q; i++) cout << p + i << " ";
cout << p << " ";
}
int main() {
int n, a, b;
cin >> n >> a >> b;
if (a < b) {
int c = a;
a = b;
b = c;
}
int na, nb = -1;
for (na = n / a; na >= 0; na--) {
if ((n - a * na) % b == 0) {
nb = (n - a * na) / b;
break;
}
}
if (nb == -1) {
cout << "-1" << endl;
return 0;
}
int in = 1;
for (int i = 0; i < na; i++) {
print(in, a);
in += a;
}
for (int i = 0; i < nb; i++) {
print(in, b);
in += b;
}
cout << endl;
return 0;
}
|
Mahmoud has an array a consisting of n integers. He asked Ehab to find another array b of the same length such that:
* b is lexicographically greater than or equal to a.
* bi ≥ 2.
* b is pairwise coprime: for every 1 ≤ i < j ≤ n, bi and bj are coprime, i. e. GCD(bi, bj) = 1, where GCD(w, z) is the greatest common divisor of w and z.
Ehab wants to choose a special array so he wants the lexicographically minimal array between all the variants. Can you find it?
An array x is lexicographically greater than an array y if there exists an index i such than xi > yi and xj = yj for all 1 ≤ j < i. An array x is equal to an array y if xi = yi for all 1 ≤ i ≤ n.
Input
The first line contains an integer n (1 ≤ n ≤ 105), the number of elements in a and b.
The second line contains n integers a1, a2, ..., an (2 ≤ ai ≤ 105), the elements of a.
Output
Output n space-separated integers, the i-th of them representing bi.
Examples
Input
5
2 3 5 4 13
Output
2 3 5 7 11
Input
3
10 3 7
Output
10 3 7
Note
Note that in the second sample, the array is already pairwise coprime so we printed it.
|
#include <bits/stdc++.h>
using namespace std;
set<int> prims;
vector<bool> used;
vector<int> divisors;
vector<bool> skip;
vector<int> nxt;
vector<int> prv;
void init_prims(int ub) {
divisors.resize(ub, 0);
for (int i = 0; i < ub; ++i) {
divisors[i] = i;
}
for (int i = 2; i < ub; ++i) {
if (divisors[i] == i) prims.insert(i);
for (int p : prims) {
if (i * p >= ub) break;
divisors[i * p] = p;
if (i % p == 0) break;
}
}
}
vector<int> factors(int x) {
vector<int> f;
while (x > 1) {
int d = divisors[x];
f.push_back(d);
while (x % d == 0) x /= d;
}
return f;
}
bool is_ok(int x) {
for (auto f : factors(x)) {
if (used[f]) return false;
}
return true;
}
int main() {
int n;
cin >> n;
const int ub = 2300000;
init_prims(ub);
used.resize(ub, 0);
nxt.resize(ub, 0);
prv.resize(ub, 0);
skip.resize(ub, false);
vector<int> v(n, 0);
for (int i = 0; i < ub - 1; ++i) nxt[i] = i + 1;
for (int i = 0; i < ub - 1; ++i) prv[i + 1] = i;
for (int i = 0; i < n; ++i) cin >> v[i];
bool le = true;
int lo = 2;
vector<int> b;
for (int i = 0; i < n; ++i) {
int a = v[i];
int start = le ? a : lo;
while (skip[start]) start = nxt[start];
if (!le) lo = nxt[start];
if (le && start > a) le = false;
b.push_back(start);
for (int d : factors(b.back())) {
for (int j = d; j < ub; j += d) {
nxt[prv[j]] = nxt[j];
prv[nxt[j]] = prv[j];
skip[j] = true;
}
}
}
for (int x : b) cout << x << " ";
cout << endl;
return 0;
}
|
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int a[maxn];
bool used[maxn];
void dfs(int v) {
used[v] = 1;
if (!used[a[v]]) dfs(a[v]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
int x = n;
for (int i = 1; i <= n; ++i)
if (!used[i]) dfs(i), x--;
if (n & 1) {
if (x & 1)
cout << "Petr";
else
cout << "Um_nik";
} else {
if (x & 1)
cout << "Um_nik";
else
cout << "Petr";
}
return 0;
}
|
Chandan is a horrendous murderer and he wants to kill Arjit just because he's lazy. Chandan is following the trail of Arjit's shoes. The trail is in the form of a k-ary tree. Arjit is lazy, sure, but he's smart. So, he magically moves away from Chandan as far as he can go.
Chandan doesn't know the way out, but he knows that Arjit has managed to travel the maximum distance he can. Help Chandan find out the maximum distance he would have to travel to find Arjit. And also tell him how much will he have to pay to travel so far. The travel rates are:
If maximum distance is <100, cost = 0.
If maximum distance is > 100, cost = 100.
If maximum distance is > 1000, cost = 1000.
If maximum distance is > 10000, cost = 10000.
Input format:
First line contains the total number of test cases. Then, the next line contains the number of nodes. The the next n lines contain three integers - the first two denote an edge between a and b, the third integer denotes the weight of that edge.
Output format:
You've to print the money Chandan will pay and the maximum distance he will have to travel.
Constraints:
1 ≤ Test Cases ≤ 10
2 ≤ n ≤ 100000
1 ≤ a, b ≤ n
1 ≤ weight ≤ 100
SAMPLE INPUT
1
5
1 2 4
3 2 3
2 5 2
4 1 1
SAMPLE OUTPUT
0 8
|
t=int(raw_input())
def bfs(x):
b=[False]*(n+1)# an array of false flags to keep track of vertices visited
memo=["p"]*(n+1)
l=0
c=0
q=[]
q.append(x)
memo[x]=0
while len(q)!=0:
#t=s[-1]
top=q.pop(0)
#l=t
b[top]=True
#q.pop(0)
for j in G[top]:
#print j
if memo[j[0]]=="p":
q.append(j[0])
memo[j[0]]=memo[top]+j[1]#time of discovery(level) of child is time of discovery(level) of parent+1
b[j[0]]=True
if memo[j[0]]>l:
l=memo[j[0]]
c=j[0]
#c+=1
#return l,c
#m=0
#m_i=0
#print memo
#for i in xrange(0,n+1):
# if type(memo[i])==int and memo[i]>m:
# m=memo[i]
# m_i=i
return l,c
while t!=0:
n=int(raw_input())
G=[[] for i in xrange(n+1)]
p=n-1
while p!=0:
x,y,z=map(int,raw_input().split())
G[x].append((y,z))#undirected graph has edge from u to v.
G[y].append((x,z))#alse has edge from v to u.
p-=1
upto,new=bfs(1)
found=False
while not found:
#print upto,new
#upto,new=bfs(new)
j=bfs(new)
#print j
if upto<j[0]:
upto=j[0]
new=j[1]
else:
found=True
if upto<100:
print 0,upto
if upto>100 and upto <1000:
print 100,upto
if upto>1000 and upto <10000:
print 1000,upto
if upto>10000:
print 10000,upto
t-=1
|
Bosky and Menot are two friends who participated in GSF Hacks Prelims on HackerEarth, and both of them easily qualified for the on-site round. Bosky wants to team up with Menot for the on-site round but Menot has a date with his girlfriend the same day. Bosky thus plans to spoil Menot’s date and trigger their breakup.
Menot and his girlfriend both use a chat application developed by Bosky. Bosky can read all the messages sent using his app, so he first wants to know whether they have postponed or preponed their date or not. To confirm the same Bosky has decided to search for all the days they have discussed about in past week and see which of the day is decided for the date. GSF Hacks is on 19th and 20th, if they are going on a date on some other day Bosky can attend GSF Hacks with his friend, otherwise he will have to come up with some other idea. Bosky knows that when his friend and his [friend’s] girlfriend have to choose a day, the girlfriend's choice is given twice more weightage than Menot's.
The problem is that Menot and his girlfriend talk a lot (-_-) and have a very long chat history which Bosky cannot read manually to know about their date. Bosky asks you to help him write a program that can do the same.
He provides you with the chat history in following format.
[G/M]*: <message>
G: I want to go on 19
M: No that is not possible lets go on 21
G: No 19 is final and 21 is not
M: OKAY as you wish
*[G means that it is Girlfriend’s message and M means that it is Menot’s message]
In the above chat history we can see that 19 have been discussed twice and 21 has also been discussed twice. But 19 have weightage 4 and 21 has weightage 3. Disregard human logic, "21 is not" will still add 21 to the weightage -- you do not need to implement NLP. Bosky thus knows that 19 has been finalised.
Note: If multiple days have same MAXIMUM weightage the date is cancelled.
Input:
First line contains an integer N and then N lines follow with a message S in the following format in each line.
[G/M]:
eg. G: Hi
[G means that it is Girlfriends message and M means that it is Menot’s message]
Note: Everything is space separated and the days will be integers with no leading zeroes and will always be preceded by a space]
Output :
Print “Date” if the decided day is 19 or 20 otherwise print “No Date”.
Note: If multiple days have same weightage the date is cancelled and you must output “No Date”
Constrains
1 ≤ N ≤ 1000
2 ≤ |S| ≤ 1000 [ Length of each message ]
1 ≤ Day ≤ 30 [ Days discussed in the chat ]
SAMPLE INPUT
4
G: I want to go on 19
M: No that is not possible lets go on 21
G: No 19 is final and 21 is not
M: OKAY as you wish
SAMPLE OUTPUT
Date
Explanation
19 have been discussed twice and 21 has also been discussed twice.
But 19 have weightage 4 and 21 has weightage 3.
Hence 19 is decided and "Date" is printed
|
days = [0]*31
for i in xrange(input()):
string = raw_input().split()
if string[0] == 'G:':
choice = [int(x) for x in string if x.isdigit()]
for gval in choice:
days[gval] += 2*(choice.count(gval))
else:
choice = [int(x) for x in string if x.isdigit()]
for gval in choice:
days[gval] += 1*(choice.count(gval))# bechara LAdka koi aukat hi ni Rahi
power = max(days)
if ( days.count(power) == 1 and (days[19] == power or days[20] == power) ):
# pehla check clash ke liye dusra Date ke Liye :D
print "Date"
else:
print "No Date"
|
As we know , Professor Dalton is teaching Compiler Design.
During his first class, he found that the students are very talkative.
so,he decided to divide the class into two sections, A & B
such that the difference between the strength of two sections
is minimum.
Print the strength of two sections in non decreasing
order.
Input : First line of the input contains number of test cases T,followed by T integers (n) (total sum of their strengths)
1≤T≤100000 , 1≤n≤100000
Output :For each test cases print strength of both section in non decreasing order
SAMPLE INPUT
2
6
8
SAMPLE OUTPUT
3 3
4 4
|
testcases = raw_input()
for i in range(int(testcases)):
tot = raw_input()
tot = int(tot)
if(tot%2==0):
a=tot/2
print a,a
else:
a=tot/2
print a,a+1
|
Gajodhar is travelling from one city to another city. Let starting city be the source and city at which his journey ends be destination. There are many intermediate cities between source and destination. Gajodhar has weak memory, so he remembers names of cities by their first character. If there are more than one intermediate cities with same first character, then he can't memorize name of those cities. So your task is to find how many cities can he remember during his journey?
Input
The first line of the input contains the number of test cases t.
The Second line of the input contains the number of intermediate cities n.
The next n lines contain names of intermediate cities. (all the names of cities are in Upper Case).
Output
For each test case print in newline the total number of cities Gajodhar can remember.
Constraints
1 ≤ t ≤ 10
1 ≤ n ≤ 10^3
SAMPLE INPUT
2
3
CHANDIGARH
MUMBAI
CHENNAI
4
KASHMIR
DELHI
BANGLORE
KANYAKUMARI
SAMPLE OUTPUT
1
2
|
t = int(raw_input())
while t:
t-=1
n = int(raw_input())
a = []
c = 0
for i in xrange(n):
b = str(raw_input())
a.append(b[0])
for i in a:
if a.count(i) == 1:
c+=1
print c
|
You are given N positive integers A1, A2, ... AN. Find the number of ways to distribute them in 2 groups in such a way that sum of numbers in each group is greater or equal K. The answer can be large so output it modulo 10^9 + 7.
Input
The first line contains two space-separated integers N and K.
The second line contains N space-separated integers: A1, A2, ... AN.
Output
Output one integer - answer for the question modulo 10^9 + 7.
Constraints
0 < N ≤ 100
0 < Ai ≤ 10^9
0 < K ≤ 10^5
0 < N ≤ 20 in 28 % of the test data.
SAMPLE INPUT
2 5
6 6
SAMPLE OUTPUT
2
|
MOD=1000000007
N,K=map(int,raw_input().split())
A=map(int,raw_input().split())
found=[0]*K
found[0]=1
Kplus=0
if sum(A)<2*K:
print 0
exit()
for a in A:
Kplus=Kplus*2
for j in range(max(0,K-a),K):
Kplus+=found[j]
Kplus%=MOD
for j in range(K-1,a-1,-1):
found[j]=(found[j]+found[j-a])%MOD
print (MOD+Kplus-sum(found)%MOD)%MOD
|
Given a binary tree in a two dimensional plane which has both side covered by mirrors.
As this is a 2D dimensional image, we define our print function to print only those nodes whose reflection is showing
on one of the mirrors, first we print the value of the nodes with reflections appearing on the right mirror and then print
the values of the ones appearing on the left and we don't need to print the same node again which has already been
printed on right mirror, so each node is going to printed only once even in a case where the node has a reflection on
both mirrors.
Suppose in the array representation of binary trees, we fill the positions where the left or right child of a node does not exist with 0s.
So the tree
3
/
2
/
1
will look in array representation as 3 2 0 1 0 0 0 0 0 0 0 0 0 0 0 i.e.
3
/ \
2 0
/ / \
1 0 0 0
/ / / / \
0 0 0 0 0 0 0 0
and the tree
1
/
2 3
will look in the array representation as 1 2 3 0 0 0 0 i.e.
1
/
2 3
/ /
0 0 0 0
here for every ith node, it's left child is at (2 * i) th and right child at (2 * i + 1)th position.
Input:
First line contains number of test cases T. First line of each test case contains a single integer N,size of array and second line contains the tree in array representation form as mentioned above.
Output:
For each test case, first print the value of the nodes with reflections appearing on the right mirror and then print values of the ones appearing on the left and
don't need to print the same node again which has already been printed on right mirror, so each node is going to printed only once even in a case where the node has a reflection on
both mirrors.
Constraints:
1 ≤ T ≤ 20
3 ≤ N ≤ 2^18
0 ≤ **A^i ≤ 1000000
Note:
The value of N will always be greater than equal to 3 and will be in the form (2^k-1) where k ≥ 2.
Last level of the tree is filled with all 0s.
Assume array indices start from 1.
SAMPLE INPUT
2
7
1 2 3 0 0 0 0
7
1 3 0 0 0 0 0SAMPLE OUTPUT
1
3
2
1
3
|
import math
def findReflection(tree,ansL,ansR,start,end):
l = end - start;
lRef = '';
rRef = '';
for v in range(0,l+1):
if tree[start+v] != '0':
lRef = v+start;
break;
for v in range(0,l+1):
if tree[end-v] != '0':
rRef = end-v;
break;
#print "Left End is : "+str(lRef)+", Right End is : "+str(rRef)
if rRef != '':
ansR.append(tree[rRef]);
if lRef != '' and lRef != rRef:
ansL.append(tree[lRef]);
x = int(raw_input());
ans = [];
for case in range(0,x):
size = int(raw_input());
tree = raw_input().split(' ');
level = int(math.log(size+1)/math.log(2))
#print "Levels are : "+str(level);
answerL = [];
answerR = [];
for step in range(0,level):
start = int(math.pow(2,step));
end = start + int(math.pow(2,step) - 1);
findReflection(tree,answerL,answerR,start-1,end-1);
for ele in answerR+answerL:
print ele
print ''
|
Given A and B, count the numbers N such that A ≤ N ≤ B and N is a palindrome.
Examples:
Palindromes: 121, 11 , 11411
Not Palindromes: 122, 10
Input:
First line contains T, the number of testcases. Each testcase consists of two integers A and B in one line.
Output:
For each testcase, print the required answer in one line.
Constraints:
1 ≤ T ≤ 10
0 ≤ A ≤ B ≤ 10^5
SAMPLE INPUT
2
10 13
20 30
SAMPLE OUTPUT
1
1
|
n = input()
def check_palindromic(x):
if str(x) == str(x)[::-1]:
return True
return False
kq = []
for i in range(n):
dem = 0
nhap = list(map(lambda x: int(x), raw_input().split()))
for j in range(nhap[0], nhap[1]+1):
if check_palindromic(j) == True:
dem += 1
kq.append(dem)
for i in kq:
print i
|
King Tle4Ever just appointed Moron as the new Engineer for his country Time Limit Exceeded. In the country of Time Limit Exceeded there are n cities and there is a direct road between each pair of cities. Now cleaning up these roads costs Tle4Ever a lot of money so he wants to demolish some of the roads but not all for sure. He wants to demolish these roads in such a way that if he picks any subset of size q of these cities, than in this subset there should exist at least one pair of cities that doesn't have a direct road between them.
He asks Moron to come up with a demolishing plan satisfying his conditions. Now, as Moron is not good at coming up with plans, he asks you to help him. Now as coming up with such a plan is really difficult, given n and q you have to tell minimum number of roads that you have to demolish to satisfy King's condition.
For example : Suppose there are 4 cities. Total number of roads in the country are 6. Suppose king chooses q as 3. Than you have to demolish at least 2 roads to satisfy King's condition. If you demolish only 1 road than there will be at least one subset of size 3 which will have road between all pair of cities. Of course you can demolish more than 2 roads but the minimum number of roads that you have to demolish are 2.
[Input]
First line of input contains a single integer t denoting number of test cases.
Next t lines contains 2 integers n and q each.
[Output]
For each test case output the minimum number of roads that you have to demolish.
[Constraints]
1 ≤ t ≤ 10^5
3 ≤ n ≤ 10^6
3 ≤ q ≤ n
SAMPLE INPUT
2
4 3
5 3
SAMPLE OUTPUT
2
4
Explanation
For case 1 : Explanation as in question.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
for _ in range(input()):
n,q = map(int,raw_input().split())
q=q-1
ans = n*n - (n%q)*((n+q-1)/q)*((n+q-1)/q) - (q - n%q)*(n/q)*(n/q)
ans/=2
ans1 =(n*(n-1))/2 -ans
print abs(ans1)
|
Jack and Jill are sitting at the bottom of their tree house and debating in how many ways then can jump up the stairs on the tree and reach the tree house .Because Jack is older than Jill, He can jump one, two or three stairs in one step while Jill can jump just one or two stairs in one step .
For example, Jack can cover the 8 stairs by jumping (2,2,2,2) or (2,1,2,1,2) or other suitable combinations of steps.
Could you help them to find the total number of possibilities they have to reach the top.
Note that the order of the steps is important here, for example, (3,1) is treated distinct from (1,3) i. e. jumping 3 stairs in first step followed by jumping 1 stair in other step is different from jumping one stair in first step and 3 stairs in second step.
Write a program to help them out
Input:
The number of stairs to be covered.
Output:
Number of total ways to reach to the top for Jack in the first line and Number of total ways to reach at the top for Jill in the second line.
(For other cases, output is ERROR)
Note: if total stairs to be covered are 3
Then,
For jack total combinations are 4
1 1 1
1 2
2 1
3
For Jill total combinations are 3
1 1 1
1 2
2 1
SAMPLE INPUT
3
SAMPLE OUTPUT
Jack-4
Jill-3
|
a = 0; b = 1; c = 1; d = 0; e = 1;
n = int(raw_input());
if n <= 0:
print "ERROR";
else:
n -= 1;
while (n):
c = a + b + c;
b = c - a - b;
a = c - b - a;
e = d + e;
d = e - d;
n -= 1;
e = d + e;
d = e - d;
print "Jack-"+str(c)+"\nJill-"+str(e);
|
A Puzzle is a game, problem, or toy that tests a person's ingenuity. In a puzzle, one is required to put pieces together, in a logical way, in order to arrive at the correct solution of the puzzle. There are different types of puzzles for different ages.Puzzles are often devised as a form of entertainment but they can also arise from serious mathematical or logistical problems.
Ananya and Bhavya are on their way to Goa. On their trip they visit a lot of different places. But one place left Ananya awe struck. She saw a lot of round big stones laid in a straight line with a number encrypted on each of them. She called this number as the value of the stones. Since they both are coders they could not leave their geekiness away for too long. So Bhavya converted the present environment to a problem. She labelled all the stones from 1 onwards. She then asked Ananya to tell her the total number of triplets such that the label of 1st stone< label of 2nd stone < label of 3rd stone and the product of value of 1st sone,value of 2nd stone and value of 3rd stone is less than or equal to a given value K that is (value of 1st stone) * (value of 2nd stone) * (value of 3rd stone) ≤ K.
Two triplets are considered different if the label value's of both the triplets are not same.
Since Ananya was not in any mood to bang her head on the stones so she asks you to help her.
Input:
The first line contains 2 integer N indicating the number of stones and the given value K.
The second line contain N space separated integers denoting the value on the encrypted stone. The first value denotes the value of stone labelled 1 the second value for stone labelled 2 and so on.
Output:
The total number of required triplets.
Constraints:
1 ≤ N ≤ 2000
1 ≤ value on any stone ≤ 10^6
1 ≤ K ≤ 1000001
SAMPLE INPUT
4 42
3 2 5 7
SAMPLE OUTPUT
2
Explanation
The required triplets are (3,2,5) and (3,2,7).
|
(N, K) = map (int, str(raw_input()).split())
nums = sorted (map (int, str(raw_input()).split()))
count = 0
for i in range(N-2):
j = i+1
k = N-1
while True:
while nums[i] * nums[j] * nums[k] > K:
k -= 1
if k == j:
break
count += k-j
j += 1
if j >= k:
break
print count
|
We have weather records at AtCoder Town for some consecutive three days. A string of length 3, S, represents the records - if the i-th character is `S`, it means it was sunny on the i-th day; if that character is `R`, it means it was rainy on that day.
Find the maximum number of consecutive rainy days in this period.
Constraints
* |S| = 3
* Each character of S is `S` or `R`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum number of consecutive rainy days in the period.
Examples
Input
RRS
Output
2
Input
SSS
Output
0
Input
RSR
Output
1
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
string s;cin>>s;
int an=0,cur=0;
for(char x:s){
if(x=='R') cur++;
else cur=0;
an=max(an,cur);
}cout<<an<<"\n";
}
|
Find \displaystyle{\sum_{a=1}^{K}\sum_{b=1}^{K}\sum_{c=1}^{K} \gcd(a,b,c)}.
Here \gcd(a,b,c) denotes the greatest common divisor of a, b, and c.
Constraints
* 1 \leq K \leq 200
* K is an integer.
Input
Input is given from Standard Input in the following format:
K
Output
Print the value of \displaystyle{\sum_{a=1}^{K}\sum_{b=1}^{K}\sum_{c=1}^{K} \gcd(a,b,c)}.
Examples
Input
2
Output
9
Input
200
Output
10813692
|
import math
K=int(input())
ans=0
for i in range(1,K+1):
for j in range(1,K+1):
for k in range(1,K+1):
ans+=math.gcd(math.gcd(i,j),k)
print(ans)
|
Takahashi bought a piece of apple pie at ABC Confiserie. According to his memory, he paid N yen (the currency of Japan) for it.
The consumption tax rate for foods in this shop is 8 percent. That is, to buy an apple pie priced at X yen before tax, you have to pay X \times 1.08 yen (rounded down to the nearest integer).
Takahashi forgot the price of his apple pie before tax, X, and wants to know it again. Write a program that takes N as input and finds X. We assume X is an integer.
If there are multiple possible values for X, find any one of them. Also, Takahashi's memory of N, the amount he paid, may be incorrect. If no value could be X, report that fact.
Constraints
* 1 \leq N \leq 50000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
If there are values that could be X, the price of the apple pie before tax, print any one of them.
If there are multiple such values, printing any one of them will be accepted.
If no value could be X, print `:(`.
Examples
Input
432
Output
400
Input
1079
Output
:(
Input
1001
Output
927
|
n = int(input())
m = 1
while int(m*1.08) < n:
m += 1
print(m) if int(m*1.08) == n else print(":(")
|
There is a blackboard on which all integers from -10^{18} through 10^{18} are written, each of them appearing once. Takahashi will repeat the following sequence of operations any number of times he likes, possibly zero:
* Choose an integer between 1 and N (inclusive) that is written on the blackboard. Let x be the chosen integer, and erase x.
* If x-2 is not written on the blackboard, write x-2 on the blackboard.
* If x+K is not written on the blackboard, write x+K on the blackboard.
Find the number of possible sets of integers written on the blackboard after some number of operations, modulo M. We consider two sets different when there exists an integer contained in only one of the sets.
Constraints
* 1 \leq K\leq N \leq 150
* 10^8\leq M\leq 10^9
* N, K, and M are integers.
Input
Input is given from Standard Input in the following format:
N K M
Output
Print the number of possible sets of integers written on the blackboard after some number of operations, modulo M.
Examples
Input
3 1 998244353
Output
7
Input
6 3 998244353
Output
61
Input
9 4 702443618
Output
312
Input
17 7 208992811
Output
128832
Input
123 45 678901234
Output
256109226
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f(i, x, n) for(int i = x; i < (int)(n); ++i)
int const N = 150, M = N >> 1;
int dp[N + 1][N + 1][N + 1], md, dp0[M + 1][M + 1];
inline void ad(int &x, int y) { if ((x += y) >= md)x -= md; }
inline void up(int i, int a, int b, int y) { ad(dp[i][a + M][b + M], y); }
int pw(int x, int p){
if (p < 0)return 0;
int an = 1;
while (p){
if (p & 1)an = (ll)an * x % md;
x = (ll)x * x % md;
p >>= 1;
}
return an;
}
int easy(int n, int k){
dp0[0][0] = 1;
f(i, 1, n + 1){
dp0[i][0] = 0;
f(j, 0, k + 1)ad(dp0[i][0], dp0[i - 1][j]);
f(j, 1, k + 1)dp0[i][j] = dp0[i - 1][j - 1];
}
int an = 0;
f(i, 0, k + 1)ad(an, dp0[n][i]);
return an;
}
int main(){
int n, k;
scanf("%d%d%d", &n, &k, &md);
if (k & 1){
dp[0][M][M] = 1;
int m = n - n / 2;
f(i, 0, n + 1)f(f1, -M, m + 1)f(f2, -M, m + 1){
int &d = dp[i][f1 + M][f2 + M];
if (i & 1){
if (-f1 >= k + 3 >> 1 && -f1 + abs(f2) >= k + 2)d = 0;
if (f1 < 0 && i - (-f1 - 1) * 2 <= 0)d = 0;
else if (f1 > 0 && i - k / 2 * 2 <= 0)d = 0;
}
else {
if (-f2 >= k + 3 >> 1 && -f2 + abs(f1) >= k + 2)d = 0;
if (f2 < 0 && i - (-f2 - 1) * 2 <= 0)d = 0;
else if (f2 > 0 && i - k / 2 * 2 <= 0)d = 0;
}
if (d == 0 || i == n)continue;
if (i & 1){
if (f2 < 0){
up(i + 1, f1, k / 2, d);
up(i + 1, f1, max(f2 - 1, -(k + 1)), d);
}
else if (f2)up(i + 1, f1, f2 - 1, d);
else {
up(i + 1, f1, 0, d);
f(j, 1, min(k / 2, m) + 1)up(i + 1, f1, j, d);
up(i + 1, f1, -(k / 2 + 1), d);
}
}else {
if (f1 < 0){
up(i + 1, k / 2, f2, d);
up(i + 1, max(f1 - 1, -(k + 1)), f2, d);
}
else if (f1)up(i + 1, f1 - 1, f2, d);
else {
up(i + 1, 0, f2, d);
f(j, 1, min(k / 2, m) + 1)up(i + 1, j, f2, d);
up(i + 1, -(k / 2 + 1), f2, d);
}
}
}
int an = 0;
f(i, -M, M + 1)f(j, -M, M + 1){
int z = dp[n][i + M][j + M];
if (z == 0)continue;
if (i >= 0)z = (ll)z * pw(2, k / 2 - i) % md;
if (j >= 0)z = (ll)z * pw(2, k / 2 - j) % md;
ad(an, z);
}
printf("%d\n", an);
}else printf("%d\n", (int)((ll)easy(n >> 1, k >> 1) * easy(n - n / 2, k >> 1) % md));
}
|
Snuke participated in a magic show.
A magician prepared N identical-looking boxes. He put a treasure in one of the boxes, closed the boxes, shuffled them, and numbered them 1 through N.
Since the boxes are shuffled, now Snuke has no idea which box contains the treasure. Snuke wins the game if he opens a box containing the treasure. You may think that if Snuke opens all boxes at once, he can always win the game. However, there are some tricks:
* Snuke must open the boxes one by one. After he opens a box and checks the content of the box, he must close the box before opening the next box.
* He is only allowed to open Box i at most a_i times.
* The magician may secretly move the treasure from a closed box to another closed box, using some magic trick. For simplicity, assume that the magician never moves the treasure while Snuke is opening some box. However, he can move it at any other time (before Snuke opens the first box, or between he closes some box and opens the next box).
* The magician can perform the magic trick at most K times.
Can Snuke always win the game, regardless of the initial position of the treasure and the movements of the magician?
Constraints
* 2 \leq N \leq 50
* 1 \leq K \leq 50
* 1 \leq a_i \leq 100
Input
Input is given from Standard Input in the following format:
N K
a_1 a_2 \cdots a_N
Output
If the answer is no, print a single `-1`.
Otherwise, print one possible move of Snuke in the following format:
Q
x_1 x_2 \cdots x_Q
It means that he opens boxes x_1, x_2, \cdots, x_Q in this order.
In case there are multiple possible solutions, you can output any.
Examples
Input
2 1
5 5
Output
7
1 1 2 1 2 2 1
Input
3 50
5 10 15
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
int main(){
int n, k;
cin >> n >> k;
vector<int> a(n);
for(int i = 0; i < n; i++){
cin >> a[i];
}
k++;
// should get all numbers to at least k+1;
int asum = 0;
int amax = 0;
for(int i = 0; i < n; i++){
a[i] = k - a[i];
if(a[i] < 0) a[i] = 0;
asum += a[i];
amax = max(amax, a[i]);
}
if(asum > k-1 || amax > (k - amax) ){
cout << -1 << '\n';
return 0;
}
vector<set<int> > f(k);
vector<int> bb(k-1);
for(int i = 0; i < k; i++){
for(int j = 0; j < n; j++){
f[i].insert(j);
}
}
int last_val = -1;
for(int s = 0; s < k-1; s++){
int best = (last_val + 1) % n;
for(int i = 0; i < n; i++){
if(i == last_val) continue;
if(a[i] > a[best]){
best = i;
}
}
last_val = best;
bb[s] = best;
f[s].erase(best);
f[s+1].erase(best);
a[best]--;
}
vector<int> ans;
for(int i = 0; i < k; i++){
if(i > 0) ans.push_back(bb[i-1]);
for(int x : f[i]){
ans.push_back(x);
}
}
cout << int(ans.size()) << '\n';
for(int x : ans){
cout << x + 1 << ' ';
}
cout << '\n';
}
|
There are N cities on a number line. The i-th city is located at coordinate x_i.
Your objective is to visit all these cities at least once.
In order to do so, you will first set a positive integer D.
Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:
* Move 1: travel from coordinate y to coordinate y + D.
* Move 2: travel from coordinate y to coordinate y - D.
Find the maximum value of D that enables you to visit all the cities.
Here, to visit a city is to travel to the coordinate where that city is located.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq X \leq 10^9
* 1 \leq x_i \leq 10^9
* x_i are all different.
* x_1, x_2, ..., x_N \neq X
Input
Input is given from Standard Input in the following format:
N X
x_1 x_2 ... x_N
Output
Print the maximum value of D that enables you to visit all the cities.
Examples
Input
3 3
1 7 11
Output
2
Input
3 81
33 105 57
Output
24
Input
1 1
1000000000
Output
999999999
|
import math
n,x=map(int,input().split());l=[abs(x-i) for i in list(map(int,input().split()))];r=0
for i in range(len(l)): r=math.gcd(r,l[i])
print(r)
|
Takahashi had a pair of two positive integers not exceeding N, (a,b), which he has forgotten. He remembers that the remainder of a divided by b was greater than or equal to K. Find the number of possible pairs that he may have had.
Constraints
* 1 \leq N \leq 10^5
* 0 \leq K \leq N-1
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N K
Output
Print the number of possible pairs that he may have had.
Examples
Input
5 2
Output
7
Input
10 0
Output
100
Input
31415 9265
Output
287927211
|
n, k = map(int, input().split())
ans = 0
for i in range(1,n+1):
ans += (n//i)*max(0,i-k)+max(0,n%i-k+1)
if k==0:
ans -= n
print(ans)
|
Rng is preparing a problem set for a qualification round of CODEFESTIVAL.
He has N candidates of problems. The difficulty of the i-th candidate is D_i.
There must be M problems in the problem set, and the difficulty of the i-th problem must be T_i. Here, one candidate of a problem cannot be used as multiple problems.
Determine whether Rng can complete the problem set without creating new candidates of problems.
Constraints
* 1 \leq N \leq 200,000
* 1 \leq D_i \leq 10^9
* 1 \leq M \leq 200,000
* 1 \leq T_i \leq 10^9
* All numbers in the input are integers.
Input
Input is given from Standard Input in the following format:
N
D_1 D_2 ... D_N
M
T_1 T_2 ... T_M
Output
Print `YES` if Rng can complete the problem set without creating new candidates of problems; print `NO` if he cannot.
Examples
Input
5
3 1 4 1 5
3
5 4 3
Output
YES
Input
7
100 200 500 700 1200 1600 2000
6
100 200 500 700 1600 1600
Output
NO
Input
1
800
5
100 100 100 100 100
Output
NO
Input
15
1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
9
5 4 3 2 1 2 3 4 5
Output
YES
|
#!/usr/bin/env python
import sys
line = sys.stdin.readline().strip()
n = int(line)
parts = sys.stdin.readline().strip().split()
nvals = map(int,parts)
nhash = {}
for item in nvals:
if nhash.has_key(item):
nhash[item] += 1
else:
nhash[item] = 1
line = sys.stdin.readline().strip()
m = int(line)
parts = sys.stdin.readline().strip().split()
mvals = map(int,parts)
mhash = {}
for item in mvals:
if mhash.has_key(item):
mhash[item] += 1
else:
mhash[item] = 1
for item in mhash.keys():
if nhash.has_key(item) and mhash[item] <= nhash[item]:
pass
else:
print "NO"
sys.exit()
print "YES"
|
There are N bags, each containing two white balls. The i-th box contains two balls with integers x_i and y_i written on them, respectively.
For each of these bags, you will paint one of the balls red, and paint the other blue.
Afterwards, the 2N balls will be classified according to color.
Then, we will define the following:
* R_{max}: the maximum integer written on a ball painted in red
* R_{min}: the minimum integer written on a ball painted in red
* B_{max}: the maximum integer written on a ball painted in blue
* B_{min}: the minimum integer written on a ball painted in blue
Find the minimum possible value of (R_{max} - R_{min}) \times (B_{max} - B_{min}).
Constraints
* 1 ≤ N ≤ 200,000
* 1 ≤ x_i, y_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the minimum possible value.
Examples
Input
3
1 2
3 4
5 6
Output
15
Input
3
1010 10
1000 1
20 1020
Output
380
Input
2
1 1
1000000000 1000000000
Output
999999998000000001
|
import sys
from operator import itemgetter
inf = 1 << 30
def solve():
n = int(sys.stdin.readline())
# r_max = MAX, b_min = MIN にしたとき
r_max = b_max = 0
r_min = b_min = inf
p = []
for i in range(n):
xi, yi = map(int, sys.stdin.readline().split())
if xi > yi:
xi, yi = yi, xi
p.append((xi, yi))
r_max = max(r_max, yi)
r_min = min(r_min, yi)
b_max = max(b_max, xi)
b_min = min(b_min, xi)
ans1 = (r_max - r_min) * (b_max - b_min)
# print('r_max = MAX, b_min = MIN -> ', ans1, file=sys.stderr)
# r_max = MAX, r_min = MIN にしたとき
ans2 = (r_max - b_min)
p.sort(key=itemgetter(0))
# print(*p, sep='\n', file=sys.stderr)
b_min = p[0][0]
b_max = p[-1][0]
y_min = inf
dif_b = b_max - b_min
for i in range(n - 1):
if p[i][1] == r_max:
break
y_min = min(y_min, p[i][1])
b_min = min(p[i + 1][0], y_min)
b_max = max(b_max, p[i][1])
# print(b_min, b_max, b_max - b_min, file=sys.stderr)
dif_b = min(dif_b, b_max - b_min)
if y_min < p[i + 1][0]:
break
ans2 *= dif_b
# print('r_max = MAX, r_min = MIN ->', ans2, file=sys.stderr)
ans = min(ans1, ans2)
print(ans)
if __name__ == '__main__':
solve()
|
We have an N×N checkerboard.
From the square at the upper left corner, a square that is i squares to the right and j squares below is denoted as (i, j). Particularly, the square at the upper left corner is denoted as (0, 0).
Each square (i, j) such that i+j is even, is colored black, and the other squares are colored white.
We will satisfy the following condition by painting some of the white squares:
* Any black square can be reached from square (0, 0) by repeatedly moving to a black square that shares a side with the current square.
Achieve the objective by painting at most 170000 squares black.
Constraints
* 1 \leq N \leq 1,000
Input
The input is given from Standard Input in the following format:
N
Output
Print the squares to paint in the following format:
K
x_1 y_1
x_2 y_2
:
x_K y_K
This means that a total of K squares are painted black, the i-th of which is (x_i, y_i).
Judging
The output is considered correct only if all of the following conditions are satisfied:
* 0 \leq K \leq 170000
* 0 \leq x_i, y_i \leq N-1
* For each i, x_i + y_i is odd.
* If i \neq j, then (x_i, y_i) \neq (x_j, y_j).
* The condition in the statement is satisfied by painting all specified squares.
Examples
Input
2
Output
1
1 0
Input
4
Output
3
0 1
2 1
2 3
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define each(itr,v) for(auto itr:v)
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcount
#define INF INT_MAX/3
struct UnionFind{
vector<int> v;
UnionFind(int n) : v(n, -1) {}
void init(){ for(int i = 0;i < v.size();i++)v[i]=-1; }
int find(int x) { return v[x] < 0 ? x : v[x] = find(v[x]); }
bool unite(int x, int y) {
x = find(x); y = find(y);
if (x == y) return false;
if (-v[x] < -v[y]) swap(x, y);
v[x] += v[y]; v[y] = x;
return true;
}
bool root(int x) { return v[x] < 0; }
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -v[find(x)]; }
};
ll n;
ll dd[]={-1,0,1,0,-1};
vector<P> res;
ll tot;
bool valid(ll i,ll j){
return i>=0&&i<n&&j>=0&&j<n;
}
int main(){
cin>>n;
rep(i,n)rep(j,n){
if((i+j)%2==0)continue;
tot++;
}
UnionFind uf(n*n);
rep(hoge,7){
rep(i,n)rep(j,n){
if((i+j)%2==0)continue;
bool ok=true;
ll cnt=0;
rep(d1,4)repl(d2,d1+1,4){
ll ni1=i+dd[d1],nj1=j+dd[d1+1];
ll ni2=i+dd[d2],nj2=j+dd[d2+1];
if(!valid(ni1,nj1)||!valid(ni2,nj2)||(ni1==ni2&&nj1==nj2))continue;
if(!uf.same(ni1*n+nj1,ni2*n+nj2))cnt++;
}
if(cnt>=7-hoge){
res.push_back(P(i,j));
rep(d1,4)rep(d2,4){
ll ni1=i+dd[d1],nj1=j+dd[d1+1];
ll ni2=i+dd[d2],nj2=j+dd[d2+1];
if(!valid(ni1,nj1)||!valid(ni2,nj2))continue;
uf.unite(ni1*n+nj1,ni2*n+nj2);
}
}
}
}
printf("%lld\n", (ll)res.size());
rep(i,res.size())printf("%lld %lld\n", res[i].se,res[i].fi);
return 0;
}
|
Write a program which judges wheather given length of three side form a right triangle. Print "YES" if the given sides (integers) form a right triangle, "NO" if not so.
Constraints
* 1 ≤ length of the side ≤ 1,000
* N ≤ 1,000
Input
Input consists of several data sets. In the first line, the number of data set, N is given. Then, N lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
Output
For each data set, print "YES" or "NO".
Example
Input
3
4 3 5
4 3 6
8 8 8
Output
YES
NO
NO
|
N = int(input())
for i in range(N):
num = sorted(map(int, input().split()))
if num[0] ** 2 + num[1] ** 2 == num[2] ** 2:
print("YES")
else:
print("NO")
|
A mischievous notice has arrived from the primitive slow-life organization "Akaruda". Akaruda is famous for mischief such as throwing a pie at the face of a VIP, but recently it has become more radical, such as using gunpowder to sprinkle rat fireworks at the reception venue. The notice is the following text.
--- Personal computer Takes human time. not good.
When the short and long hands of the clock meet, Akaruda justice is done.
Slow life great.
It's terrifying and I'm not sure, but it seems to mean that the mischief is carried out when the minute hand and the minute hand of the clock overlap.
To be wary of this mischief, create a program that inputs the time and outputs "alert" if the short hand and the long hand are close, "safe" if they are far, and "warning" otherwise. However, "close" means that the angle between the short hand and the long hand is 0 ° or more and less than 30 °, and "far" means that the angle is 90 ° or more and 180 ° or less. The time should be between 00:00 and 11:59.
Input
The input is given in the following format:
n
hh1: mm1
hh2: mm2
::
hhn: mmn
The number of times to be judged on the first line n (1 ≤ n ≤ 10000), and the i-th time hhi: mmi on the second and subsequent lines are given to each line.
Output
Output the judgment result of the i-th time safe, warning, or alert in order on one line.
Example
Input
4
02:15
06:01
11:55
10:40
Output
alert
safe
alert
warning
|
#include<iostream>
#include<cstdlib>
#include<algorithm>
using namespace std;
int main(){
int n;
cin>>n;
for(int i=0;i<n;i++){
int h,m;
char _;
cin>>h>>_>>m;
int d=min(abs(h*60+m-12*m) , 720-max(h*60+m,12*m)+min(h*60+m,12*m));
if(d<30*2){
cout<<"alert\n";
}else if(d<90*2){
cout<<"warning\n";
}else{
cout<<"safe\n";
}
}
return 0;
}
|
There was a big old mansion in one place, and one cat settled in. As shown in the figure, the mansion has a convex polygonal shape when viewed from above, and is made up of several rooms surrounded by straight walls. One wall is supported by pillars at both ends. The mansion is so old that every wall has one hole that allows cats to pass through. Cats can move between rooms and rooms in the mansion or between rooms and outside through holes in the wall.
<image>
The owner of the mansion whistles and calls the cat out of the mansion to feed the cat. The cat is very smart, and when his husband whistles, he "best chooses" to get out of the mansion. That is, it goes out through the hole the least number of times.
The cat is very capricious and I don't know which room it is in. Therefore, the time it takes for a cat to get out of the mansion varies from day to day, and the husband was at a loss because he didn't know how long to wait. At one point, the husband noticed that it took a long time for the cat to go through the hole. This means that the time it takes for a cat to get out depends on the number of times it passes through the hole. The husband wondered if he could know the maximum number of times the cat would pass through the hole if he made the "best choice", no matter what room the cat was in, and how long he should wait. .. My husband knows the floor plan of the mansion, but the mansion is so big that I can't calculate it myself ...
Create a program that reads the floor plan of the mansion and outputs the maximum number of holes that the cat will pass through when it makes the "best choice".
input
The input consists of multiple datasets. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format.
C W
x1 y1
x2 y2
::
xC yC
s1 t1
s2 t2
::
sW tW
The numbers given on each line are separated by a single space.
The number of columns C (3 ≤ C ≤ 100) and the number of walls W (3 ≤ W ≤ 300) are given in the first line. The coordinates of the column are given in the following C line. xi (-1000 ≤ xi ≤ 1000) is the x-coordinate of the i-th column, and yi (-1000 ≤ yi ≤ 1000) is the y-coordinate of the i-th column. Each pillar is assigned a number from 1 to C. The wall information is given in the following W line.
si (1 ≤ si ≤ C) and ti (1 ≤ ti ≤ C) indicate the number of columns that support both ends of the wall.
The input may be considered to satisfy the following conditions.
* Different pillars do not occupy the same position.
* Different walls do not overlap or intersect except on pillars.
* One pillar supports two or more walls.
* Wall length is greater than 0.
* Pillars are only on both ends of the wall. That is, the pillar is never in the middle of the wall.
* The wall separates two different rooms, or the room and the outside.
* When you choose any two different pillars, you can reach each other by following the wall.
The number of datasets does not exceed 50.
output
For each dataset, if the cat makes the "best choice", it prints the maximum number of holes it can pass before it goes out on a single line.
Example
Input
4 4
0 0
1 0
1 1
0 1
1 2
1 4
2 3
3 4
12 22
2 0
4 0
8 0
4 2
6 2
8 2
2 4
4 4
6 4
0 6
8 6
0 8
1 2
2 3
1 4
1 7
1 10
2 4
2 5
3 5
3 6
4 5
4 8
5 6
5 9
6 9
6 11
7 10
7 8
8 9
9 11
10 11
10 12
11 12
0 0
Output
1
3
|
#include <bits/stdc++.h>
#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)
#define _all(arg) begin(arg),end(arg)
template<class T>bool chmax(T &a, const T &b) { return (a<b)?(a=b,1):0;}
template<class T>bool chmin(T &a, const T &b) { return (b<a)?(a=b,1):0;}
using namespace std;
using R=long double;
using edge=tuple<R,int>;
const int limit=310;
int x[limit],y[limit];
int main(void){
int n,m;
while(cin >> n >> m,n){
rep(i,n) cin >> x[i] >> y[i];
vector<edge> graph[limit];
vector<int> used[limit];
rep(i,m){
int s,t;
cin >> s >> t;
s--,t--;
graph[s].push_back(make_tuple(atan2(y[t]-y[s],x[t]-x[s]),t));
used[s].push_back(-1);
graph[t].push_back(make_tuple(atan2(y[s]-y[t],x[s]-x[t]),s));
used[t].push_back(-1);
}
rep(v,n) sort(_all(graph[v]));
int all=0;
rep(v,n){
rep(i,graph[v].size()){
if(used[v][i]!=-1) continue;
int cur=v,idx=i;
do{
used[cur][idx]=all;
int nxt=get<1>(graph[cur][idx]),nidx=0;
rep(j,graph[nxt].size()) if(get<1>(graph[nxt][j])==cur) nidx=(j+1)%int(graph[nxt].size());
cur=nxt,idx=nidx;
}while(cur!=v);
all++;
}
}
int dual[limit][limit];
rep(i,all)rep(j,all) dual[i][j]=(i==j)?0:(1<<20);
int outer=used[min_element(x,x+n)-x][0];
rep(v,n){
rep(i,graph[v].size()){
int v2=get<1>(graph[v][i]),j=0;
while(get<1>(graph[v2][j])!=v) j++;
dual[used[v][i]][used[v2][j]]=1;
dual[used[v2][j]][used[v][i]]=1;
}
}
rep(k,all)rep(i,all)rep(j,all) chmin(dual[i][j],dual[i][k]+dual[k][j]);
int ans=1;
rep(v,all) chmax(ans,dual[outer][v]);
cout << ans << endl;
}
return 0;
}
|
problem
JOI Shoji manages the time spent at work by employees with a time card. When an employee arrives at the office, he / she uses a dedicated device to stamp the arrival time on the time card. When leaving the office after work, the time of leaving the office is stamped on the time card. The time is handled in a 24-hour clock.
For security reasons, employees arrive at work after 7 o'clock. In addition, all employees leave the company before 23:00. The employee leaving time is always after the time of arrival.
Create a program that calculates the time spent at work for each of the three JOI Shoji employees, Mr. A, Mr. B, and Mr. C, given the time of arrival and departure.
input
The input consists of 3 lines. Mr. A's arrival time and departure time are written on the first line, Mr. B's arrival time and departure time are written on the second line, and Mr. C's arrival time and departure time are separated by blanks on the third line. There is.
The time is written with three integers, each separated by a space. The three integers h, m, and s represent h hours, m minutes, and s seconds. 7 ≤ h ≤ 22, 0 ≤ m ≤ 59, 0 ≤ s ≤ 59.
output
Output Mr. A's time at work on the first line, Mr. B's time at work on the second line, and Mr. C's time at work on the third line.
If the output time is h hours, m minutes, and s seconds, output in the order of h, m, and s, separated by blanks.
Examples
Input
9 0 0 18 0 0
9 0 1 18 0 0
12 14 52 12 15 30
Output
9 0 0
8 59 59
0 0 38
Input
None
Output
None
|
#include <cstdio>
int main (int argc, char const* argv[])
{
int a,b,c,d,e,f,t,i;
for(i=0;i<3;i++){
scanf("%d%d%d%d%d%d",&a,&b,&c,&d,&e,&f);
t=d*60*60+e*60+f-a*60*60-b*60-c;
printf("%d %d %d\n",t/3600%60,t/60%60,t%60);
}
return 0;
}
|
Since I got tired to write long problem statements, I decided to make this problem statement short. For given positive integer L, how many pairs of positive integers a, b (a ≤ b) such that LCM(a, b) = L are there? Here, LCM(a, b) stands for the least common multiple of a and b.
Constraints
* 1 ≤ L ≤ 1012
Input
For each dataset, an integer L is given in a line. Input terminates when L = 0.
Output
For each dataset, output the number of pairs of a and b.
Example
Input
12
9
2
0
Output
8
3
2
|
#include<cstdio>
#include<vector>
#define pb push_back
using namespace std;
typedef vector<int> vi;
int main(){
static bool era[1000000];
for(int i=2;i<100;i++){
if(!era[i]) for(int j=i*i;j<1000000;j+=i) era[j]=true;
}
vi pr;
for(int i=2;i<1000000;i++) if(!era[i]) pr.pb(i);
int n=pr.size();
for(long long L;scanf("%lld",&L),L;){
if(L==1){ puts("1"); continue; }
vi q;
int old=-1;
for(int i=0;i<n&&L>1;){
if(L%pr[i]==0){
L/=pr[i];
if(old==i) q.back()++;
else q.pb(1);
old=i;
}
else i++;
}
if(L>1) q.pb(1);
int prod=1;
for(int i=0;i<q.size();i++) prod*=(2*q[i]+1);
printf("%d\n",(prod-1)/2+1);
}
return 0;
}
|
Life is not easy. Sometimes it is beyond your control. Now, as contestants of ACM ICPC, you might be just tasting the bitter of life. But don't worry! Do not look only on the dark side of life, but look also on the bright side. Life may be an enjoyable game of chance, like throwing dice. Do or die! Then, at last, you might be able to find the route to victory.
This problem comes from a game using a die. By the way, do you know a die? It has nothing to do with "death." A die is a cubic object with six faces, each of which represents a different number from one to six and is marked with the corresponding number of spots. Since it is usually used in pair, "a die" is rarely used word. You might have heard a famous phrase "the die is cast," though.
When a game starts, a die stands still on a flat table. During the game, the die is tumbled in all directions by the dealer. You will win the game if you can predict the number seen on the top face at the time when the die stops tumbling.
Now you are requested to write a program that simulates the rolling of a die. For simplicity, we assume that the die neither slip nor jumps but just rolls on the table in four directions, that is, north, east, south, and west. At the beginning of every game, the dealer puts the die at the center of the table and adjusts its direction so that the numbers one, two, and three are seen on the top, north, and west faces, respectively. For the other three faces, we do not explicitly specify anything but tell you the golden rule: the sum of the numbers on any pair of opposite faces is always seven.
Your program should accept a sequence of commands, each of which is either "north", "east", "south", or "west". A "north" command tumbles the die down to north, that is, the top face becomes the new north, the north becomes the new bottom, and so on. More precisely, the die is rotated around its north bottom edge to the north direction and the rotation angle is 9 degrees. Other commands also tumble the die accordingly to their own directions. Your program should calculate the number finally shown on the top after performing the commands in the sequence. Note that the table is sufficiently large and the die never falls off during the game.
Input
The input consists of one or more command sequences, each of which corresponds to a single game. The first line of a command sequence contains a positive integer, representing the number of the following command lines in the sequence. You may assume that this number is less than or equal to 1024. A line containing a zero indicates the end of the input. Each command line includes a command that is one of north, east, south, and west. You may assume that no white space occurs in any line.
Output
For each command sequence, output one line containing solely the number of the top face at the time when the game is finished.
Example
Input
1
north
3
north
east
south
0
Output
5
1
|
#include<iostream>
#include<string>
using namespace std;
void Run(int&, int&, int&, int&);
int main(){
int i, n, top, bottom, north, south, west, east;
string str;
while(1){
cin >> n;
if(n == 0) break;
top = 1;
bottom = 6;
north = 2;
south = 5;
west = 3;
east = 4;
for(i=0; i<n; ++i){
cin >> str;
if(str == "south")
Run(top, north, bottom, south);
else if(str == "north")
Run(top, south, bottom, north);
else if(str == "east")
Run(top, west, bottom, east);
else if(str == "west")
Run(top, east, bottom, west);
}
cout << top << endl;
}
return 0;
}
void Run(int& a, int& b, int& c, int& d){
int e;
e = a;
a = b;
b = c;
c = d;
d = e;
}
|
Consider a binary tree whose leaves are assigned integer weights. Such a tree is called balanced if, for every non-leaf node, the sum of the weights in its left subtree is equal to that in the right subtree. For instance, the tree in the following figure is balanced.
<image>
Figure I.1. A balanced tree
A balanced tree is said to be hidden in a sequence A, if the integers obtained by listing the weights of all leaves of the tree from left to right form a subsequence of A. Here, a subsequence is a sequence that can be derived by deleting zero or more elements from the original sequence without changing the order of the remaining elements.
For instance, the balanced tree in the figure above is hidden in the sequence 3 4 1 3 1 2 4 4 6, because 4 1 1 2 4 4 is a subsequence of it.
Now, your task is to find, in a given sequence of integers, the balanced tree with the largest number of leaves hidden in it. In fact, the tree shown in Figure I.1 has the largest number of leaves among the balanced trees hidden in the sequence mentioned above.
Input
The input consists of multiple datasets. Each dataset represents a sequence A of integers in the format
N
A1 A2 . . . AN
where 1 ≤ N ≤ 1000 and 1 ≤ Ai ≤ 500 for 1 ≤ i ≤ N. N is the length of the input sequence, and Ai is the i-th element of the sequence.
The input ends with a line consisting of a single zero. The number of datasets does not exceed 50.
Output
For each dataset, find the balanced tree with the largest number of leaves among those hidden in A, and output, in a line, the number of its leaves.
Example
Input
9
3 4 1 3 1 2 4 4 6
4
3 12 6 3
10
10 9 8 7 6 5 4 3 2 1
11
10 9 8 7 6 5 4 3 2 1 1
8
1 1 1 1 1 1 1 1
0
Output
6
2
1
5
8
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcountll
#define INF 1e16
#define mod 1000000007
int N;
int A[1000];
int solve(int k){
vector<int> a;
int sum=0;
rep(i,N){
if(A[i]%k!=0)continue;
int tmp=A[i]/k;
while(tmp%2==0)tmp/=2;
if(tmp!=1)continue;
a.push_back(A[i]/k);
sum+=A[i]/k;
}
if((int)a.size()==0)return 0;
int M=a.size();
vector<int> dp(sum+1,-1);
dp[0]=0;
rep(i,M){
for(int j=sum-a[i];j>=0;j--){
if(dp[j]==-1)continue;
if((j&(a[i]-1))==0&&j+a[i]<=sum)maxch(dp[j+a[i]],dp[j]+1);
}
}
int res=0;
for(int j=1;j<=sum;j<<=1)maxch(res,dp[j]);
return res;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
while(1){
cin>>N;
if(N==0)break;
rep(i,N)cin>>A[i];
int res=0;
repl(k,1,501){
maxch(res,solve(k));
}
cout<<res<<endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.