text stringlengths 49 983k |
|---|
#include<iostream>
#include<cstdio>
#include<cfloat>
#include<cassert>
#include<cmath>
#include<vector>
#include<algorithm>
#include<set>
using namespace std;
#define EPS (1e-12)
#define equals(a, b) (fabs((a) - (b)) < EPS )
#define dle(a, b) (equals(a, b) || a < b )
static const double PI = acos(-1);
class Point{
public:
double x, y;
Point ( double x = 0, double y = 0): x(x), y(y){}
Point operator + ( Point p ){ return Point(x + p.x, y + p.y); }
Point operator - ( Point p ){ return Point(x - p.x, y - p.y); }
Point operator * ( double a ){ return Point(x*a, y*a); }
Point operator / ( double a ){ return Point(x/a, y/a); }
Point operator / ( Point p ) { return Point((x*p.x+y*p.y)/(p.x*p.x+p.y*p.y), (y*p.x-x*p.y)/(p.x*p.x+p.y*p.y)); }
double abs() { return sqrt(norm());}
double norm() { 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 fabs(x-p.x) < EPS && fabs(y-p.y) < EPS;
}
};
typedef Point Vector;
class Segment{
public:
Point p1, p2;
Segment(Point s = Point(), Point t = Point()): p1(s), p2(t){}
};
typedef Segment Line;
static const int CIRCLE_NON = 0;
static const int CIRCLE_OUT = 1;
static const int CIRCLE_IN = 2;
static const int CIRCLE_CROSS = 3;
class Circle{
public:
Point c;
double r;
Circle(Point c = Point(), double r = 0.0): c(c), r(r){}
};
typedef vector<Point> Polygon;
double norm( Vector a ){ return a.x*a.x + a.y*a.y; }
double abs( Vector a ){ return sqrt(norm(a)); }
Point polar( double a, double r ){ return Point(cos(r)*a, sin(r)*a);}
double getDistance( Vector a, Vector b ){ return abs(a - b); }
double dot( Vector a, Vector b ){ return a.x*b.x + a.y*b.y; }
double cross( Vector a, Vector b ){ return a.x*b.y - a.y*b.x; }
double arg(Vector p){ return atan2(p.y, p.x); }
Point project( Segment s, Point p ){
Vector base = s.p2 - s.p1;
double t = dot(p - s.p1, base)/norm(base);
return s.p1 + base*t;
}
Point reflect( Segment s, Point p ){
return p + (project(s, p) - p)*2.0;
}
bool isOnSegment( Point a, Point b, Point c){
if ( a == c || b == c ) return true;
return (abs(a-c) + abs(c-b) < abs(a-b) + EPS );
}
bool isParallel( Vector a, Vector b ){
return equals( cross(a, b), 0.0 );
}
bool isParallel( Point a1, Point a2, Point b1, Point b2){
return isParallel( a1 - a2, b1 - b2 );
}
bool isParallel( Segment s1, Segment s2 ){
return equals( cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0 );
}
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;
// EPS can be 0
// need to check for 920, 833, 866
int ccw( Point p0, Point p1, Point p2 ){
Vector a = p1 - p0;
Vector b = p2 - p0;
if ( cross(a, b) > EPS ) return COUNTER_CLOCKWISE;
if ( cross(a, b) < -EPS ) return CLOCKWISE;
if ( dot(a, b) < -EPS ) return ONLINE_BACK;
if ( norm(a) < norm(b) ) return ONLINE_FRONT;
return ON_SEGMENT;
}
// intersect Segment p1-p2 and Segment p3-p4 ?
bool isIntersect(Point p1, Point p2, Point p3, Point p4){
return ( ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0 );
}
// intersect Segment s1 and Segment s2 ?
// verified by 920, 833, 866, uoa2062
bool isIntersect(Segment s1, Segment s2){
return isIntersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
// verified by 920, 833, uoa2062
Point getCrossPoint(Segment s1, Segment s2){
assert( isIntersect(s1, s2) );
Vector base = s2.p2 - s2.p1;
double d1 = abs(cross(base, s1.p1 - s2.p1));
double d2 = abs(cross(base, s1.p2 - s2.p1));
double t = d1/(d1 + d2);
return s1.p1 + (s1.p2 - s1.p1)*t;
}
Point getCrossPointLines( Line s1, Line s2){
Vector a = s1.p2 - s1.p1;
Vector base = s2.p2 - s2.p1;
return s1.p1 + a * cross(base, s2.p1 - s1.p1)/cross(base, a);
}
double getDistanceLP(Line s, Point p){
return abs(cross(s.p2 - s.p1, p - s.p1)/abs(s.p2 - s.p1));
}
// 10514
double getDistance(Segment s, Point p){
if ( dot(s.p2 - s.p1, p - s.p1) < 0.0 ) return abs(p - s.p1);
if ( dot(s.p1 - s.p2, p - s.p2) < 0.0 ) return abs(p - s.p2);
return abs(cross(s.p2 - s.p1, p - s.p1)/abs(s.p2 - s.p1));
}
double getDistance(Segment s1, Segment s2){
if ( isIntersect(s1, s2) ) return 0.0;
return min( min(getDistance(s1, s2.p1), getDistance(s1, s2.p2)),
min(getDistance(s2, s1.p1), getDistance(s2, s1.p2)));
}
bool isIntersect( Circle c1, Line l ){
double d = getDistanceLP(l, c1.c);
return ( equals(d, c1.r) || d < c1.r );
}
pair<Point, Point> getTangentPoints(Point p, Circle c){
double d = abs(c.c - p);
double t = arg(c.c - p);
double b = sqrt(d*d - c.r * c.r);
double a = asin(c.r / d);
Point p1 = p + polar(b, t + a);
Point p2 = p + polar(b, t - a);
return make_pair(p1, p2);
}
int N, D;
Circle C[10];
vector<Point> SX, GX; // contact points
vector<Point> P; // target points
int getNumOfXCircles(Segment s){
int cnt = 0;
for ( int i = 0; i < N; i++ ){
double d = getDistance(s, C[i].c);
if ( d < C[i].r && !equals(d, C[i].r)) cnt++;
}
return cnt;
}
bool inCircle(Point p){
for ( int i = 0; i < N; i++ ){
if ( abs(p - C[i].c) < C[i].r && !equals(abs(p-C[i].c), C[i].r) ) return true;
}
return false;
}
int main(){
cin >> N >> D;
Point S = Point(25, 0);
Point G = Point(25, 94);
for ( int i = 0; i < N; i++ ){
cin >> C[i].c.x >> C[i].c.y >> C[i].r;
}
for ( int i = 0; i < N; i++ ){
pair<Point, Point> cp;
cp = getTangentPoints(S, C[i]);
SX.push_back(cp.first);
SX.push_back(cp.second);
cp = getTangentPoints(G, C[i]);
GX.push_back(cp.first);
GX.push_back(cp.second);
}
for ( int i = 0; i < SX.size(); i++ ){
Line l1 = Line(S, SX[i]);
for ( int j = 0; j < GX.size(); j++ ){
Line l2 = Line(G, GX[j]);
if ( !isParallel(l1, l2) ){
Point p = getCrossPointLines(l1, l2);
if ( 0 < p.x && 0 < p.y && p.x < 50 && p.y < 94) P.push_back(p);
}
}
}
double ans = 10000;
bool ok = false;
for ( int i = 0; i < P.size(); i++ ){
//printf("%.8lf, %.8lf\n", P[i].x, P[i].y);
int cnt = 0;
cnt += getNumOfXCircles(Segment(S, P[i]));
cnt += getNumOfXCircles(Segment(G, P[i]));
if ( inCircle(P[i]) ) cnt--;
if ( cnt <= D ){
ok = true;
ans = min(ans, abs(P[i]-S) + abs(P[i]-G));
}
}
if ( getNumOfXCircles(Segment(S, G) ) <= D ){
ans = min(ans, abs(S - G));
ok = true;
}
if ( ok ){
printf("%.10lf\n", ans);
} else {
cout << -1 << endl;
}
return 0;
} |
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
#include <cassert>
#include <queue>
#include <set>
#include <map>
#include <valarray>
#include <bitset>
#include <stack>
#include <iomanip>
#include <fstream>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define chmax(a,b) (a<b?(a=b,1):0)
#define chmin(a,b) (a>b?(a=b,1):0)
#define valid(y,x,h,w) (0<=y&&y<h&&0<=x&&x<w)
const int INF = 1<<29;
#define double long double
const double EPS = 1e-7;
const double PI = acos(-1);
typedef long long ll;
typedef pair<int,int> pii;
typedef complex<double> P;
P pIN() { double x,y; cin >> x >> y; return P(x,y); }
namespace std {
bool operator < (const P& a, const P& b) {
// if (abs(a-b)<EPS) return 0;
return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
}
double cross(const P& a, const P& b) {
return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
return real(conj(a)*b);
}
struct L : public vector<P> {
L(const P &a, const P &b) {
push_back(a); push_back(b);
}
L() { resize(2); }
};
ostream &operator<<(ostream &os, const L &a) {
os << a[0] << " -> " << a[1];
return os;
}
typedef vector<P> G;
#define curr(P, i) P[i]
#define next(P, i) P[(i+1)%P.size()]
struct C {
P p; double r;
C() {}
C(const P &p, double r) : p(p), r(r) { }
};
int ccw(P a, P b, P c) {
b -= a; c -= a;
if (cross(b, c) > EPS) return +1; // counter clockwise
if (cross(b, c) < -EPS) return -1; // clockwise
if (dot(b, c) < -EPS) return +2; // c--a--b on line
if (norm(b) < norm(c)) return -2; // a--b--c on line
return 0;
}
bool intersectLL(const L &l, const L &m) {
return abs(cross(l[1]-l[0], m[1]-m[0])) > EPS || // non-parallel
abs(cross(l[1]-l[0], m[0]-l[0])) < EPS; // same line
}
bool intersectLS(const L &l, const L &s) {
return cross(l[1]-l[0], s[0]-l[0])* // s[0] is left of l
cross(l[1]-l[0], s[1]-l[0]) < EPS; // s[1] is right of l
}
bool intersectLP(const L &l, const P &p) {
return abs(cross(l[1]-p, l[0]-p)) < EPS;
}
bool intersectSS(const L &s, const L &t) {
return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSS2(const L &s, const L &t) { // 接しているやつは交差と考えない
REP(i, 2) {
if (ccw(s[0], s[1], t[i]) == 0) {
int c = ccw(s[0],s[1],t[!i]);
if (s[0] == t[i]) {
if (c!=-2&&c) return 0;
} else if (s[1] == t[i]) {
if (c!=2&&c) return 0;
} else if (abs(c)==1) return 0;
}
}
return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSP(const L &s, const P &p) {
return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
}
bool intersectLH(const L &l, const L &h) {
if (intersectLS(l,h)) return 1;
if (!intersectLL(l,h)) return 0;
if (abs(cross(l[1]-l[0],h[1]-h[0])) < EPS) return 1; // same line
return (ccw(l[0],l[1],h[0]) == 1) ^ (cross(l[1]-l[0], h[1]-h[0]) > 0);
}
bool intersectHS(const L &h, const L &s) {
if (intersectSS(h,s)) return 1;
if (!intersectLS(h,s)) return 0;
if (abs(cross(s[1]-s[0],h[1]-h[0])) < EPS) // same line
return ccw(h[0],h[1],s[0]) != 2 || ccw(h[0],h[1],s[1]) != 2;
return (ccw(s[0],s[1],h[0]) == 1) ^ (cross(s[1]-s[0], h[1]-h[0]) > 0);
}
bool intersectHH(const L &h, const L &k) {
return intersectLH(h,k) && intersectLH(k,h);
}
bool intersectHS2(const L &h, const L &s) {
L t(s); swap(t[0],t[1]);
return intersectHH(h,s) && intersectHH(h,t);
}
P projection(const L &l, const P &p) {
double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
return l[0] + t*(l[0]-l[1]);
}
P reflection(const L &l, const P &p) {
return p + P(2,0) * (projection(l, p) - p);
}
vector<L> tangentCP(const C &c, const P &p) {
vector<L> ret;
P vect = c.p - p;
double d = abs(vect);
double l = sqrt(d*d-c.r*c.r);
if (::isnan(l)) { return ret; }
P v1 = vect * P(l / d, c.r / d);
P v2 = vect * P(l / d, -c.r / d);
ret.push_back(L(p, p+v1));
if (l > EPS)
ret.push_back(L(p, p+v2));
return ret;
}
P crosspoint(const L &l, const L &m) {
double A = cross(l[1] - l[0], m[1] - m[0]);
double B = cross(l[1] - l[0], l[1] - m[0]);
if (abs(A) < EPS && abs(B) < EPS) return m[0]; // same line
if (abs(A) < EPS) assert(false); // !!!PRECONDITION NOT SATISFIED!!!
return m[0] + B / A * (m[1] - m[0]);
}
double distanceSP(const L &s, const P &p) {
const P r = projection(s, p);
if (intersectSP(s, r)) return abs(r - p);
return min(abs(s[0] - p), abs(s[1] - p));
}
C circles[10];
int n,d;
double ans;
P start(25,0);
P goal(25,94);
void check(const P &p) {
if (p.real() < -EPS || p.real() > 50+EPS || p.imag() < -EPS || p.imag() > 94+EPS) {
return;
}
int cnt = 0;
REP(i,n) {
bool f1 = distanceSP(L(start, p), circles[i].p) <= circles[i].r - EPS;
bool f2 = distanceSP(L(goal, p), circles[i].p) <= circles[i].r - EPS;
if (f1 || f2) {
cnt++;
}
if (f1 && f2 && abs(p-circles[i].p) > circles[i].r+EPS) {
cnt++;
}
}
if (cnt <= d) {
chmin(ans, abs(start-p)+abs(goal-p));
}
}
int main() {
while(cin >> n >> d) {
REP(i,n) {
int x,y,r;
cin >> x >> y >> r;
circles[i] = C(P(x,y),r);
}
ans = INF;
check(start);
vector<L> v;
v.push_back(L(P(0,0),P(50,0)));
v.push_back(L(P(50,0),P(50,94)));
v.push_back(L(P(50,94),P(0,94)));
v.push_back(L(P(0,94),P(0,0)));
REP(i,n) {
vector<L> v1 = tangentCP(circles[i], start);
vector<L> v2 = tangentCP(circles[i], goal);
FOR(it, v1) v.push_back(*it);
FOR(it, v2) v.push_back(*it);
}
FOR(it, v) {
FOR(jt, v) {
if (intersectLL(*it, *jt)) {
P p = crosspoint(*it, *jt);
check(p);
}
}
}
if (ans == INF) cout << -1 << endl;
else printf("%.10Lf\n", ans);
}
} |
#include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <algorithm>
#include <cmath>
#include <array>
using namespace std;
const double EPS = 1e-8;
const double INF = 1e12;
const double PI = acos(-1);
#define EQ(n,m) (abs((n)-(m)) < EPS)
#define X real()
#define Y imag()
typedef complex<double> P;
typedef vector<P> VP;
struct L : array<P, 2>{
L(const P& a, const P& b){ at(0)=a; at(1)=b; }
L(){}
};
struct C{
P p;
double r;
C(const P& p, const double& r) : p(p), r(r) {}
C(){}
};
namespace std{
bool operator < (const P& a, const P& b){
return !EQ(a.X,b.X) ? a.X<b.X : a.Y+EPS<b.Y;
}
bool operator == (const P& a, const P& b){
return abs(a-b) < EPS;
}
}
double dot(P a, P b){
return (conj(a)*b).X;
}
double cross(P a, P b){
return (conj(a)*b).Y;
}
int ccw(P a, P b, P c){
b -= a;
c -= a;
if(cross(b,c) > EPS) return +1; //ccw
if(cross(b,c) < -EPS) return -1; //cw
if(dot(b,c) < -EPS) return +2; //c-a-b
if(abs(c)-abs(b) > EPS) return -2; //a-b-c
return 0; //a-c-b
}
P unit(const P &p){
return p/abs(p);
}
P rotate(const P &p, double rad){
return p *P(cos(rad), sin(rad));
}
bool intersectSS(const L& a, const L& b){
return ( ccw(a[0],a[1],b[0]) *ccw(a[0],a[1],b[1]) <= 0 ) &&
( ccw(b[0],b[1],a[0]) *ccw(b[0],b[1],a[1]) <= 0 );
}
P projection(const L& l, const P& p) {
double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
return l[0] + t*(l[0]-l[1]);
}
double distanceLP(const L &l, const P &p) {
return abs(cross(l[1]-l[0], p-l[0])) /abs(l[1]-l[0]);
}
double distanceSP(const L &s, const P &p) {
if(dot(s[1]-s[0], p-s[0]) < EPS) return abs(p-s[0]);
if(dot(s[0]-s[1], p-s[1]) < EPS) return abs(p-s[1]);
return distanceLP(s, p);
}
bool isParallel(const P &a, const P &b){
return abs(cross(a,b)) < EPS;
}
bool isParallel(const L &a, const L &b){
return isParallel(a[1]-a[0], b[1]-b[0]);
}
P crosspointLL(const L &l, const L &m) {
double A = cross(l[1]-l[0], m[1]-m[0]);
double B = cross(l[1]-l[0], l[1]-m[0]);
return m[0] + B/A *(m[1]-m[0]);
}
VP crosspointCL(const C &c, const L &l){
VP ret;
P mid = projection(l, c.p);
double d = distanceLP(l, c.p);
if(EQ(d, c.r)){
ret.push_back(mid);
}else if(d < c.r){
double len = sqrt(c.r*c.r -d*d);
ret.push_back(mid +len*unit(l[1]-l[0]));
ret.push_back(mid -len*unit(l[1]-l[0]));
}
return ret;
}
vector<L> getTangentLine(const C &c, const P &p){
vector<L> ret;
P dir = p -c.p;
if(c.r < abs(dir) +EPS){
P a = c.p + c.r*unit(dir);
VP cp = crosspointCL(C(c.p, abs(dir)), L(a, a+dir*P(0,1)));
for(int i=0; i<(int)cp.size(); i++){
ret.push_back(L(p, c.p +c.r*unit(cp[i]-c.p)));
}
}
return ret;
}
int main(){
int n,d;
cin >> n >> d;
vector<C> c(n);
for(int i=0; i<n; i++){
double x,y,r;
cin >> x >> y >> r;
c[i] = C(P(x, y), r);
}
P s(25, 0), g(25, 94);
vector<L> tangent;
for(int i=0; i<n; i++){
vector<L> ret = getTangentLine(c[i], s);
tangent.insert(tangent.end(), ret.begin(), ret.end());
ret = getTangentLine(c[i], g);
tangent.insert(tangent.end(), ret.begin(), ret.end());
}
VP cand;
cand.push_back((s+g)/2.0);
for(int i=0; i<(int)tangent.size(); i++){
for(int j=i+1; j<(int)tangent.size(); j++){
if(!isParallel(tangent[i], tangent[j])){
P cp = crosspointLL(tangent[i], tangent[j]);
if(0 < cp.X +EPS && cp.X < 50 +EPS && 0 < cp.Y +EPS && cp.Y < 94 +EPS){
cand.push_back(cp);
}
}
}
}
double ans = INF;
for(int i=0; i<(int)cand.size(); i++){
L e[2] = {L(s, cand[i]), L(g, cand[i])};
int count = 0;
for(int j=0; j<n; j++){
if(abs(cand[i] -c[j].p) +EPS < c[j].r){
count++;
continue;
}
if(distanceSP(e[0], c[j].p) +EPS < c[j].r) count++;
if(distanceSP(e[1], c[j].p) +EPS < c[j].r) count++;
}
if(count <= d){
ans = min(ans, abs(e[0][1] -e[0][0]) +abs(e[1][1] -e[1][0]));
}
}
if(ans == INF){
cout << -1 << endl;
}else{
cout << fixed << setprecision(10);
cout << ans << endl;
}
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<cfloat>
#include<cassert>
#include<cmath>
#include<vector>
#include<algorithm>
#include<set>
using namespace std;
#define EPS (1e-12)
#define equals(a, b) (fabs((a) - (b)) < EPS )
#define dle(a, b) (equals(a, b) || a < b )
static const double PI = acos(-1);
class Point{
public:
double x, y;
Point ( double x = 0, double y = 0): x(x), y(y){}
Point operator + ( Point p ){ return Point(x + p.x, y + p.y); }
Point operator - ( Point p ){ return Point(x - p.x, y - p.y); }
Point operator * ( double a ){ return Point(x*a, y*a); }
Point operator / ( double a ){ return Point(x/a, y/a); }
Point operator / ( Point p ) { return Point((x*p.x+y*p.y)/(p.x*p.x+p.y*p.y), (y*p.x-x*p.y)/(p.x*p.x+p.y*p.y)); }
double abs() { return sqrt(norm());}
double norm() { 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 fabs(x-p.x) < EPS && fabs(y-p.y) < EPS;
}
};
typedef Point Vector;
class Segment{
public:
Point p1, p2;
Segment(Point s = Point(), Point t = Point()): p1(s), p2(t){}
};
typedef Segment Line;
static const int CIRCLE_NON = 0;
static const int CIRCLE_OUT = 1;
static const int CIRCLE_IN = 2;
static const int CIRCLE_CROSS = 3;
class Circle{
public:
Point c;
double r;
Circle(Point c = Point(), double r = 0.0): c(c), r(r){}
};
typedef vector<Point> Polygon;
double norm( Vector a ){ return a.x*a.x + a.y*a.y; }
double abs( Vector a ){ return sqrt(norm(a)); }
Point polar( double a, double r ){ return Point(cos(r)*a, sin(r)*a);}
double getDistance( Vector a, Vector b ){ return abs(a - b); }
double dot( Vector a, Vector b ){ return a.x*b.x + a.y*b.y; }
double cross( Vector a, Vector b ){ return a.x*b.y - a.y*b.x; }
double arg(Vector p){ return atan2(p.y, p.x); }
Point project( Segment s, Point p ){
Vector base = s.p2 - s.p1;
double t = dot(p - s.p1, base)/norm(base);
return s.p1 + base*t;
}
Point reflect( Segment s, Point p ){
return p + (project(s, p) - p)*2.0;
}
bool isOnSegment( Point a, Point b, Point c){
if ( a == c || b == c ) return true;
return (abs(a-c) + abs(c-b) < abs(a-b) + EPS );
}
bool isParallel( Vector a, Vector b ){
return equals( cross(a, b), 0.0 );
}
bool isParallel( Point a1, Point a2, Point b1, Point b2){
return isParallel( a1 - a2, b1 - b2 );
}
bool isParallel( Segment s1, Segment s2 ){
return equals( cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0 );
}
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;
// EPS can be 0
// need to check for 920, 833, 866
int ccw( Point p0, Point p1, Point p2 ){
Vector a = p1 - p0;
Vector b = p2 - p0;
if ( cross(a, b) > EPS ) return COUNTER_CLOCKWISE;
if ( cross(a, b) < -EPS ) return CLOCKWISE;
if ( dot(a, b) < -EPS ) return ONLINE_BACK;
if ( norm(a) < norm(b) ) return ONLINE_FRONT;
return ON_SEGMENT;
}
// intersect Segment p1-p2 and Segment p3-p4 ?
bool isIntersect(Point p1, Point p2, Point p3, Point p4){
return ( ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0 );
}
// intersect Segment s1 and Segment s2 ?
// verified by 920, 833, 866, uoa2062
bool isIntersect(Segment s1, Segment s2){
return isIntersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
// verified by 920, 833, uoa2062
Point getCrossPoint(Segment s1, Segment s2){
assert( isIntersect(s1, s2) );
Vector base = s2.p2 - s2.p1;
double d1 = abs(cross(base, s1.p1 - s2.p1));
double d2 = abs(cross(base, s1.p2 - s2.p1));
double t = d1/(d1 + d2);
return s1.p1 + (s1.p2 - s1.p1)*t;
}
Point getCrossPointLines( Line s1, Line s2){
Vector a = s1.p2 - s1.p1;
Vector base = s2.p2 - s2.p1;
return s1.p1 + a * cross(base, s2.p1 - s1.p1)/cross(base, a);
}
double getDistanceLP(Line s, Point p){
return abs(cross(s.p2 - s.p1, p - s.p1)/abs(s.p2 - s.p1));
}
// 10514
double getDistance(Segment s, Point p){
if ( dot(s.p2 - s.p1, p - s.p1) < 0.0 ) return abs(p - s.p1);
if ( dot(s.p1 - s.p2, p - s.p2) < 0.0 ) return abs(p - s.p2);
return abs(cross(s.p2 - s.p1, p - s.p1)/abs(s.p2 - s.p1));
}
double getDistance(Segment s1, Segment s2){
if ( isIntersect(s1, s2) ) return 0.0;
return min( min(getDistance(s1, s2.p1), getDistance(s1, s2.p2)),
min(getDistance(s2, s1.p1), getDistance(s2, s1.p2)));
}
bool isIntersect( Circle c1, Line l ){
double d = getDistanceLP(l, c1.c);
return ( equals(d, c1.r) || d < c1.r );
}
pair<Point, Point> getTangentPoints(Point p, Circle c){
double d = abs(c.c - p);
double t = arg(c.c - p);
double b = sqrt(d*d - c.r * c.r);
double a = asin(c.r / d);
Point p1 = p + polar(b, t + a);
Point p2 = p + polar(b, t - a);
return make_pair(p1, p2);
}
int N, D;
Circle C[10];
vector<Point> SX, GX; // contact points
vector<Point> P; // target points
int getNumOfXCircles(Segment s){
int cnt = 0;
for ( int i = 0; i < N; i++ ){
double d = getDistance(s, C[i].c);
if ( d < C[i].r && !equals(d, C[i].r)) cnt++;
}
return cnt;
}
bool inCircle(Point p){
for ( int i = 0; i < N; i++ ){
if ( abs(p - C[i].c) < C[i].r && !equals(abs(p-C[i].c), C[i].r) ) return true;
}
return false;
}
int main(){
cin >> N >> D;
Point S = Point(25, 0);
Point G = Point(25, 94);
for ( int i = 0; i < N; i++ ){
cin >> C[i].c.x >> C[i].c.y >> C[i].r;
}
for ( int i = 0; i < N; i++ ){
pair<Point, Point> cp;
cp = getTangentPoints(S, C[i]);
SX.push_back(cp.first);
SX.push_back(cp.second);
cp = getTangentPoints(G, C[i]);
GX.push_back(cp.first);
GX.push_back(cp.second);
}
for ( int i = 0; i < SX.size(); i++ ){
Line l1 = Line(S, SX[i]);
for ( int j = 0; j < GX.size(); j++ ){
Line l2 = Line(G, GX[j]);
if ( !isParallel(l1, l2) ){
Point p = getCrossPointLines(l1, l2);
if ( 0 < p.x && 0 < p.y && p.x < 50 && p.y < 94) P.push_back(p);
}
}
}
double ans = 10000;
bool ok = false;
for ( int i = 0; i < P.size(); i++ ){
//printf("%.8lf, %.8lf\n", P[i].x, P[i].y);
int cnt = 0;
cnt += getNumOfXCircles(Segment(S, P[i]));
cnt += getNumOfXCircles(Segment(G, P[i]));
if ( inCircle(P[i]) ) cnt--;
if ( cnt <= D ){
ok = true;
ans = min(ans, abs(P[i]-S) + abs(P[i]-G));
}
}
if ( getNumOfXCircles(Segment(S, G) ) <= D ){
ans = min(ans, abs(S - G));
ok = true;
}
if ( ok ){
printf("%.8lf\n", ans);
} else {
cout << -1 << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
struct SegmentTree
{
vector< pair< int, int > > seg;
int sz;
SegmentTree(int n)
{
sz = 1;
while(sz < n) sz <<= 1;
seg.assign(2 * sz - 1, make_pair(0, 0));
}
void push(int k)
{
if(k >= sz - 1 || seg[k] == make_pair(0, 0)) return;
if(seg[2 * k + 1] == make_pair(0, 0)) {
seg[2 * k + 1] = seg[k];
} else if(seg[k].first == seg[2 * k + 1].second) {
seg[2 * k + 1].second = seg[k].second;
} else {
seg[2 * k + 1] = {-1, -1};
}
if(seg[2 * k + 2] == make_pair(0, 0)) {
seg[2 * k + 2] = seg[k];
} else if(seg[k].first == seg[2 * k + 2].second) {
seg[2 * k + 2].second = seg[k].second;
} else {
seg[2 * k + 2] = {-1, -1};
}
seg[k] = {0, 0};
}
void update(int a, int b, int x, int k, int l, int r)
{
push(k);
if(a >= r || b <= l) {
} else if(a <= l && r <= b) {
if(seg[k] == make_pair(-1, -1)) return;
if(k >= sz - 1) {
if(seg[k].second == x) seg[k].second++;
else seg[k] = {-1, -1};
} else {
seg[k] = {x, x + 1};
}
push(k);
} else {
update(a, b, x, 2 * k + 1, l, (l + r) >> 1);
update(a, b, x, 2 * k + 2, (l + r) >> 1, r);
}
}
void update(int a, int b, int x)
{
update(a, b, x, 0, 0, sz);
}
int query(int a, int b, int x, int k, int l, int r)
{
push(k);
if(a >= r || b <= l) return (0);
if(a <= l && r <= b) {
return (seg[k] == make_pair(0, x));
}
return (query(a, b, x, 2 * k + 1, l, (l + r) >> 1) +
query(a, b, x, 2 * k + 2, (l + r) >> 1, r));
}
int query(int a, int b, int x)
{
return (query(a, b, x, 0, 0, sz));
}
};
int main()
{
int N, K, T;
scanf("%d %d", &N, &K);
scanf("%d", &T);
SegmentTree tree(N);
while(T--) {
int l, r, x;
scanf("%d %d %d", &l, &r, &x);
tree.update(--l, r, --x);
}
int ret = 0;
for(int i = 0; i < N; i++) ret += tree.query(i, i + 1, K);
printf("%d\n", ret);
} |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e+9;
using P = pair<int,int>;
int n,k,t,ans;
set<int> st[200010];
vector<P> on[200010],off[200010];
int calc(int x){
return (st[x].size() == 2 && *(st[x - 1].begin()) < *(st[x].begin()))
+ (st[x + 1].size() == 2 && *(st[x].begin()) < *(st[x + 1].begin()));
}
signed main(){
cin >> n >> k >> t;
for(int i = 0;i < t;i++){
int l,r,x;
cin >> l >> r >> x; l--;r--;
on[l].emplace_back(i,x);
off[r].emplace_back(i,x);
}
st[0].insert(-1);
for(int i = 0;i <= k + 1;i++) st[i].insert(INF);
int cnt = 0;
for(int i = 0;i < n;i++){
for(P p : on[i]){
cnt -= calc(p.second);
st[p.second].insert(p.first);
cnt += calc(p.second);
}
if(cnt == k) ans++;
for(P p : off[i]){
cnt -= calc(p.second);
st[p.second].erase(p.first);
cnt += calc(p.second);
}
}
cout << ans << endl;
}
|
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <queue>
#include <cmath>
using namespace std;
#define SIZE 300000
#define INF 1000000000
int blockState[SIZE];
int blockL[SIZE], blockR[SIZE];
int item[SIZE];
int rN;
void applyBlock(int id, int x) {
if (blockState[id] == 0) {
blockL[id] = blockR[id] = x;
blockState[id] = 1;
}
else if (blockState[id] == 1) {
if (blockR[id] + 1 == x)
blockR[id] = x;
else
blockState[id] = 2;
}
}
void applyNode(int pos, int x) {
int id = pos / rN;
int l = id * rN;
int r = (id + 1) * rN;
if (blockState[id] == 1) {
for (int i=l; i<r; i++) {
if (item[i] + 1 == blockL[id])
item[i] = blockR[id];
else
item[i] = INF;
}
blockState[id] = 0;
}
if (blockState[id] == 2) {
for (int i=l; i<r; i++)
item[i] = INF;
blockState[id] = 0;
}
if (x == -1) return;
if (item[pos] + 1 == x) {
item[pos] = x;
} else {
item[pos] = INF;
}
}
int main() {
int N, K, T;
scanf("%d%d%d", &N, &K, &T);
rN = sqrt(N);
int blockSize = (N + rN-1) / rN;
for (int i=0; i<blockSize; i++) {
blockL[i] = -1;
blockR[i] = -1;
}
for (int i=0; i<T; i++) {
int l, r, x;
scanf("%d%d%d", &l, &r, &x);
l--;
//[l, r)
for (int i=l; i<(l/rN+1)*rN; i++)
if (i < r)
applyNode(i, x);
for (int i=r/rN*rN; i<r; i++)
if (i >= (l/rN+1)*rN)
applyNode(i, x);
for (int i=l/rN+1; i<r/rN; i++)
applyBlock(i, x);
}
for (int i=0; i<blockSize; i++)
applyNode(i*rN, -1);
int ans = 0;
for (int i=0; i<N; i++)
ans += item[i] == K;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N,K,T;
const int B = 100;
int from[200010/B+1], to[200010/B+1];
int val[200010/B*B+B];
void show(){
return;
for(int i = 0; i < N; ++i){
cout << val[i] << ' ';
}
cout << endl;
for(int i = 0; i < N/B; ++i){
cout << from[i] << ' ';
}
cout << endl;
for(int i = 0; i < N/B; ++i){
cout << to[i] << ' ';
}
cout << endl;
}
void sync(int b){
if(from[b] == -1) return;
for(int i = b*B; i < (b+1)*B; ++i){
if(val[i] == from[b]){
val[i] = to[b];
} else {
val[i] = -2;
}
}
from[b] = -1;
to[b] = -1;
}
void naive(int l, int r, int x){
for(int i = l; i < r; ++i){
val[i] = (val[i] == x-1) ? x : -2;
}
}
void exec(int l, int r, int x){
if(l/B == r/B){
sync(l/B);
naive(l,r,x);
} else {
if(l%B){
sync(l/B);
naive(l, l-l%B+B, x);
l = l-l%B+B;
}
if(r%B){
sync(r/B);
naive(r-r%B, r, x);
r = r-r%B;
}
while(l+B <= r){
// cout << "u" << l << endl;
if(to[l/B] != -1){
to[l/B] = (to[l/B] == x-1) ? x : -2;
} else {
from[l/B] = x-1;
to[l/B] = x;
}
l += B;
}
}
show();
}
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
cin >> N >> K;
cin >> T;
memset(from, -1, sizeof from);
memset(to, -1, sizeof to);
while(N%B) ++N;
for(int it = 0; it < T; ++it){
int l,r,x;
cin >> l >> r >> x;
--l;
exec(l,r,x);
}
for(int i = 0; i < N/B; ++i){
sync(i);
}
show();
cout << count(val, val+N, K) << endl;
} |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1<<18;
struct po{int l,r;};
int n;
po dat[2*MAX_N-1];
void init(int n_){
n=1;
while(n<n_)n*=2;
for(int i=0;i<2*n-1;i++)dat[i]=(po){0,0};
}
void compute(int k,po t){
if(t.r==0)return;
if(dat[k].r==0) dat[k]=t;
else if(dat[k].r==t.l-1)dat[k].r=t.r;
else dat[k]=(po){-1,-1};
}
void query(int a,int b,int x,int k=0,int l=0,int r=n){
if(r<=a||b<=l)return ;
if(a<=l&&r<=b){
compute(k,(po){x,x});
return ;
}
int left=k*2+1,right=k*2+2;
compute(left,dat[k]);
compute(right,dat[k]);
dat[k]=(po){0,0};
query(a,b,x,left,l,(l+r)/2);
query(a,b,x,right,(l+r)/2,r);
}
int main(){
int N,k;
cin>>n>>k;
N=n;
init(n);
int q;
cin>>q;
while(q--){
int l,r,x;
cin>>l>>r>>x;
query(l-1,r,x);
}
int ans=0;
for(int i=0;i<N;i++){
query(i,i+1,k+1);
ans+=(dat[i+n-1].l==1&&dat[i+n-1].r==k+1);
}
cout <<ans<<endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
#define INF (1e8)
int N,K,T;
P dat[(1<<19)];
void compute(int k,P p){
if(p==P(0,0))return;
if(dat[k]==P(0,0)){
dat[k]=p;
}else if(dat[k].second+1==p.first){
dat[k].second=p.second;
}else{
dat[k]=P(INF,INF);
}
}
void add(int a,int b,int x,int k=0,int l=0,int r=(1<<18)){
if(b<=l || r<=a)return;
if(a<=l && r<=b){
compute(k,P(x,x));
return;
}
compute(k*2+1,dat[k]);
compute(k*2+2,dat[k]);
dat[k]=P(0,0);
int m=(l+r)/2;
add(a,b,x,k*2+1,l,m);
add(a,b,x,k*2+2,m,r);
}
int main(){
scanf("%d %d %d",&N,&K,&T);
for(int i=0;i<T;i++){
int l,r,x;
scanf("%d %d %d",&l,&r,&x);
add(l-1,r,x);
}
for(int i=0;i<N;i++){
add(i,i+1,0);
}
int ans=0;
for(int i=0;i<N;i++){
int p=i+(1<<18)-1;
if(dat[p]==P(1,K))ans++;
}
printf("%d\n",ans);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
const int B = 450;
// 現在の状態
int s[B][B] = {};
int F[B];
int T[B];
bool bad[B]={};
void push(int bid){
if(bad[bid]){
rep(i,B) s[bid][i] = -1;
return;
}
if(F[bid] == -1) return;
rep(i,B){
if(s[bid][i] == F[bid]) s[bid][i] = T[bid];
else s[bid][i] = -1;
}
F[bid] = -1;
T[bid] = -1;
}
void D(int l, int r, int x){
int lid = l/B, rid = r/B;
if(lid == rid){
push(lid);
for(int i=l; i<=r; ++i){
if(s[i/B][i%B] == x-1) s[i/B][i%B] = x;
else s[i/B][i%B] = -1;
}
}
else{
push(lid);
push(rid);
for(int i=l; i<B*(lid+1); ++i){
if(s[i/B][i%B] == x-1) s[i/B][i%B] = x;
else s[i/B][i%B] = -1;
}
for(int bid=lid+1; bid<rid; ++bid){
if(F[bid] == -1){
F[bid] = x-1;
T[bid] = x;
}
else{
if(T[bid] == x-1) T[bid] = x;
else bad[bid] = true;
}
}
for(int i=B*rid; i<=r; ++i){
if(s[i/B][i%B] == x-1) s[i/B][i%B] = x;
else s[i/B][i%B] = -1;
}
}
}
int main(){
int n,k,t;
scanf(" %d %d %d", &n, &k, &t);
fill(F,F+B,-1);
fill(T,T+B,-1);
rep(i,t){
int l,r,x;
scanf(" %d %d %d", &l, &r, &x);
--l;
--r;
D(l,r,x);
}
rep(i,B) push(i);
int ans = 0;
rep(i,n) ans += (s[i/B][i%B] == k);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int invalid = -2;
class square_root_decomposition {
public:
square_root_decomposition(int N)
: B(sqrt(N))
{
N = (N + B - 1) / B * B;
before.assign(N / B, -1);
after.assign(N / B, -1);
donut.assign(N, 0);
}
void eval(int b) {
if(before[b] == -1) {
return;
}
for(int i = B * b; i < B * (b + 1); ++i) {
if(donut[i] == before[b]) {
donut[i] = after[b];
} else {
donut[i] = invalid;
}
}
before[b] = after[b] = -1;
}
void update_block(int b, int x) {
if(after[b] != -1) {
if(after[b] == x - 1) {
after[b] = x;
} else {
after[b] = invalid;
}
} else {
before[b] = x - 1;
after[b] = x;
}
}
void update_naive(int l, int r, int x) {
for(int i = l; i <= r; ++i) {
if(donut[i] == x - 1) {
donut[i] = x;
} else {
donut[i] = invalid;
}
}
}
void update(int l, int r, int x) {
if(l / B == r / B) {
eval(l / B);
update_naive(l, r, x);
} else {
int bl = l / B;
int br = r / B;
if(l % B != 0) {
eval(l / B);
update_naive(l, (l + B - 1) / B * B - 1, x);
bl++;
}
if(r % B != B - 1) {
eval(r / B);
update_naive(r - r % B, r, x);
br--;
}
for(int i = bl; i <= br; ++i) {
update_block(i, x);
}
}
}
int query(int k) {
for(int i = 0; i < (int)before.size(); ++i) {
eval(i);
}
return count(begin(donut), end(donut), k);
}
void dbg() {
for(int i = 0; i < (int)donut.size(); ++i) {
cout << "dbg donut: " << i << ' ' << donut[i] << endl;
}
for(int b = 0; b < (int)before.size(); ++b) {
cout << "dbg block: " << b << ' ' << before[b] << ' ' << after[b] << endl;
}
}
private:
const int B;
vector<int> before, after;
vector<int> donut;
};
int main() {
int N, K, T;
cin >> N >> K;
cin >> T;
square_root_decomposition sq(N);
for(int i = 0; i < T; ++i) {
int l, r, x;
cin >> l >> r >> x;
sq.update(l-1, r-1, x);
}
cout << sq.query(K) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const function<P(P, P)> minQ = [](P l, P r) { return min(l, r); };
template <typename T>
class LazySegmentTree {
using func_t = function<T(T, T)>;
const int n;
const T id1, id2;
func_t merge;
func_t change;
vector<T> data, lazy;
int size(int n) {
int res = 1;
while (res < n) res <<= 1;
return res;
}
void propa(int node) {
if (lazy[node] == id2) return;
if (node < n) {
lazy[node * 2] = change(lazy[node * 2], lazy[node]);
lazy[node * 2 + 1] = change(lazy[node * 2 + 1], lazy[node]);
}
data[node] = change(data[node], lazy[node]);
lazy[node] = id2;
}
void suc(int l, int r, int node, int lb, int ub, T val) {
if (ub <= l || r <= lb) return;
propa(node);
if (l <= lb && ub <= r) {
lazy[node] = val;
return;
}
int c = (lb + ub) / 2;
suc(l, r, node * 2, lb, c, val);
suc(l, r, node * 2 + 1, c, ub, val);
data[node] = merge(change(data[node * 2], lazy[node * 2]), change(data[node * 2 + 1], lazy[node * 2 + 1]));
}
T sub(int l, int r, int node, int lb, int ub) {
if (ub <= l || r <= lb) return id1;
propa(node);
if (l <= lb && ub <= r) {
return data[node];
}
int c = (lb + ub) / 2;
return merge(sub(l, r, node * 2, lb, c), sub(l, r, node * 2 + 1, c, ub));
}
public:
LazySegmentTree(int n_, T id1_, T id2_, func_t merge_, func_t change_)
: n(size(n_)), id1(id1_), id2(id2_), merge(merge_), change(change_), data(n * 2, id1), lazy(n * 2, id2) {}
void update(int l, int r, T val) {
suc(l, r + 1, 1, 0, n, val);
}
T find(int l) {
sub(l, l + 1, 1, 0, n);
return data[l + n];
}
};
template <typename T>
class SegmentTree {
const int n;
const T id;
vector<T> data, data2;
int size(int n) {
int res = 1;
while (res < n) res <<= 1;
return res;
}
T sub(int l, int r, int node, int lb, int ub) {
if (ub <= l || r <= lb) return id;
if (l <= lb && ub <= r) {
return data[node] + data2[node] * (ub - lb);
}
return data2[node] * (min(r, ub) - max(l, lb))
+ sub(l, r, node * 2, lb, (lb + ub) / 2)
+ sub(l, r, node * 2 + 1, (lb + ub) / 2, ub);
}
void suc(int l, int r, int node, int lb, int ub, T val) {
if (ub <= l || r <= lb) return;
if (l <= lb && ub <= r) {
data2[node] += val;
return;
}
data[node] += val * (min(r, ub) - max(l, lb));
suc(l, r, node * 2, lb, (lb + ub) / 2, val);
suc(l, r, node * 2 + 1, (lb + ub) / 2, ub, val);
}
public:
SegmentTree(int n_) :
n(size(n_)), id(0), data(n * 2, id), data2(n * 2, id) {}
void add(int l, int r, T val) {
suc(l, r + 1, 1, 0, n, val);
}
T getSum(int l, int r) {
return sub(l, r + 1, 1, 0, n);
}
};
int main()
{
int N, K, T;
cin >> N >> K >> T;
LazySegmentTree<P> lst(N, P(0, 0), P(-1, -1), minQ, [](P l, P r) {
if (l == P(-1, -1)) return r;
if (r == P(-1, -1)) return l;
if (l == P(-2, -2) || r == P(-2, -2)) return P(-2, -2);
return l.second == r.first ? P(l.first, r.second) : P(-2, -2);
});
for (int i = 0, l, r, x; i < T; i++) {
cin >> l >> r >> x; l--; r--;
lst.update(l, r, P(x - 1, x));
}
int res = 0;
for (int i = 0; i < N; i++) {
if (lst.find(i) == P(0, K)) {
res++;
}
}
cout << res << endl;
return 0;
} |
#include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define rrep(i,n) for(int i=(int)(n)-1;i>=0;--i)
#define srep(i,s,t) for(int i=(int)(s);i<(int)(t);++i)
#define each(a,b) for(auto& (a): (b))
#define all(v) (v).begin(),(v).end()
#define len(v) (int)(v).size()
#define zip(v) sort(all(v)),v.erase(unique(all(v)),v.end())
#define cmx(x,y) x=max(x,y)
#define cmn(x,y) x=min(x,y)
#define fi first
#define se second
#define pb push_back
#define show(x) cout<<#x<<" = "<<(x)<<endl
#define spair(p) cout<<#p<<": "<<p.fi<<" "<<p.se<<endl
#define sar(a,n) cout<<#a<<":";rep(pachico,n)cout<<" "<<a[pachico];cout<<endl
#define svec(v) cout<<#v<<":";rep(pachico,v.size())cout<<" "<<v[pachico];cout<<endl
#define svecp(v) cout<<#v<<":";each(pachico,v)cout<<" {"<<pachico.first<<":"<<pachico.second<<"}";cout<<endl
#define sset(s) cout<<#s<<":";each(pachico,s)cout<<" "<<pachico;cout<<endl
#define smap(m) cout<<#m<<":";each(pachico,m)cout<<" {"<<pachico.first<<":"<<pachico.second<<"}";cout<<endl
using namespace std;
typedef pair<int,int> P;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<P> vp;
typedef vector<string> vs;
const int MAX_N = 200005;
#define getchar getchar_unlocked
#define putchar putchar_unlocked
inline int in() {
int n = 0; short c;
while ((c = getchar()) >= '0') n = n * 10 + c - '0';
return n;
}
vector<int> vec[MAX_N];
int id[MAX_N];
int main()
{
int n = in(), K = in(), T = in();
rep(i,T){
int l = in(),r = in();
id[i] = in();
vec[l-1].pb(T+i);
vec[r].pb(i);
}
set<P> st = {P(-1,INF), P(T,INF)};
int ans = 0, cnt = 0, sm = 0;
rep(i,n){
each(val,vec[i]){
if(val >= T){
cnt++;
val -= T;
auto it = st.lower_bound(P(val,INF));
int nx = it->se;
--it;
int prv = it->se;
if(nx-prv==1) sm--;
if(nx == id[val]+1) sm++;
if(prv == id[val]-1) sm++;
st.insert(P(val,id[val]));
}else{
cnt--;
auto it = st.lower_bound(P(val,INF));
int nx = it->se;
--it, --it;
int prv = it->se;
++it, st.erase(it);
if(nx-id[val]==1) sm--;
if(id[val]-prv==1) sm--;
if(nx-prv==1) sm++;
}
}
if(cnt == K && sm == K-1) ans++;
}
cout << ans << "\n";
return 0;
}
|
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <string>
#include <bitset>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <sstream>
#include <stack>
#include <iomanip>
using namespace std;
inline char nc(){
static char buf[100000],*p1=buf,*p2=buf;
if (p1==p2) { p2=(p1=buf)+fread(buf,1,100000,stdin); if (p1==p2) return EOF; }
return *p1++;
}
inline void read(int &x){
char c=nc(),b=1;
for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}
const int N=200005;
struct abcd{
int l,r;
abcd(int l=-1,int r=-1):l(l),r(r) { }
bool operator == (const abcd &B) const{
return l==B.l && r==B.r;
}
}T[N<<2];
bool Jud(abcd L,abcd R){
return L.r+1==R.l;
}
inline void Push(int x,abcd u){
if (T[x]==abcd(-1,-1)) { T[x]=u; return; }
if (T[x]==abcd(-2,-2)) return;
if (u==abcd(-2,-2)) { T[x]=u; return; }
if (Jud(T[x],u) || T[x]==abcd(-1,-1)) T[x].r=u.r;
else T[x]=abcd(-2,-2);
}
inline void Modify(int x,int l,int r,int ql,int qr,abcd u){
int mid=(l+r)>>1;
if (!(T[x]==abcd(-1,-1)) && l!=r) Push(x<<1,T[x]),Push(x<<1|1,T[x]),T[x]=abcd(-1,-1);
if (ql<=l && r<=qr){
Push(x,u);
return;
}
if (ql<=mid) Modify(x<<1,l,mid,ql,qr,u);
if (mid<qr) Modify(x<<1|1,mid+1,r,ql,qr,u);
}
int n,K;
int cnt=0;
inline void Query(int x,int l,int r){
if (l==r){
if (T[x]==abcd(0,K))
cnt++;
return;
}
if (!(T[x]==abcd(-1,-1)) && l!=r) Push(x<<1,T[x]),Push(x<<1|1,T[x]),T[x]=abcd(-1,-1);
int mid=(l+r)>>1;
Query(x<<1,l,mid);
Query(x<<1|1,mid+1,r);
}
int main(){
int Q; int l,r,c;
read(n); read(K);
T[1]=abcd(0,0);
read(Q);
while (Q--){
read(l); read(r); read(c);
Modify(1,1,n,l,r,abcd(c,c));
}
Query(1,1,n);
printf("%d\n",cnt);
return 0;
} |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;++i)
using namespace std;
using pii = pair<int, int>;
#define fst first
#define snd second
const pii fail = pii(-1, -1);
inline pii exec(pii cur, pii add) {
if (cur == fail or add == fail) return fail;
if (cur.snd == 0) return add;
if (cur.snd != add.fst) return fail;
return pii(cur.fst, add.snd);
}
const int sz = 1 << 18;
pii data[2 * sz], lazy[2 * sz];
inline void lazy_eval(int k) {
if (lazy[k].snd == 0) return;
for (int nk = 2 * k + 1; nk <= 2 * k + 2; ++nk) {
data[nk] = exec(data[nk], lazy[k]);
lazy[nk] = exec(lazy[nk], lazy[k]);
}
lazy[k].snd = 0;
}
void query(int a, int b, int k, pii add, int l, int r) {
if (b <= l or r <= a ) return;
if (a <= l and r <= b) {
data[k] = exec(data[k], add);
lazy[k] = exec(lazy[k], add);
return ;
}
lazy_eval(k);
const int m = (l + r) / 2;
query(a, b, 2 * k + 1, add, l, m);
query(a, b, 2 * k + 2, add, m, r);
}
int main(void) {
int n, k, t;
cin >> n >> k >> t;
rep(i, 2 * sz) {
data[i] = pii(0, 1);
lazy[i] = pii(0, 0);
}
rep(loop, t) {
int l, r, x;
cin >> l >> r >> x, l--;
query(l, r, 0, pii(x, x + 1), 0, sz);
}
rep(i, sz - 1) lazy_eval(i);
int ans = 0;
rep(i, n){
//cerr << data[sz - 1 + i].fst << " " << data[sz - 1 + i].snd << endl;
if (data[sz - 1 + i].fst == 0 and data[sz - 1 + i].snd == k + 1) ans++;
}
cout << ans << endl;
} |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
struct inv{
int l,r; //closed interval
inv(int a=0,int b=0):l(a),r(b){}
inv operator+=(inv x){
if(l==0 && r==0)l = x.l, r = x.r;
else if(r+1==x.l)r = x.r;
else l=-1,r=-1;
return *this;
}
bool operator==(inv x){ return l==x.l && r==x.r; }
bool operator!=(inv x){ return l!=x.l || r!=x.r; }
};
class SegmentTree{
int n;
vector<inv> node;
public:
SegmentTree(int n_){
n = 1;
while(n<n_)n*=2;
node.resize(2*n-1);
for(int i=0;i<2*n-1;i++)node[i] = inv(0,0);
}
inv get(int x){
x += n-1;
inv res = node[x];
while(x){
x = (x-1)/2;
if(node[x] != inv(0,0)){
res += node[x];
}
}
return res;
}
void add(int l, int r, inv x){
add(l,r,x,0,n,0);
}
void add(int l, int r, inv x, int a, int b, int k){
if(r<=a || b<=l)return;
if(l<=a && b<=r){
node[k] += x;
return;
}
if(node[k] != inv(0,0)){
add(a,(a+b)/2,node[k],a,(a+b)/2,2*k+1);
add((a+b)/2,b,node[k],(a+b)/2,b,2*k+2);
}
add(l,r,x,a,(a+b)/2,2*k+1);
add(l,r,x,(a+b)/2,b,2*k+2);
node[k] = inv(0,0);
}
};
int main(){
int n,k,t;
cin >> n >> k >> t;
SegmentTree st(n);
for(int i=0;i<t;i++){
int l,r,x;
cin >> l >> r >> x; l--;
st.add(l,r,inv(x,x));
}
int ans = 0;
for(int i=0;i<n;i++){
if(st.get(i) == inv(1,k))ans++;
}
cout << ans << endl;
} |
#include<bits/stdc++.h>
using namespace std;
#define BS 500
#define MAX 214514
int up[500],fr[500],to[500],ou[500];
int dn[MAX];
void eval(int p){
if(!up[p]) return;
for(int j=BS*p;j<BS*(p+1);j++){
if(dn[j]==fr[p]) dn[j]=to[p];
else dn[j]=-1;
}
up[p]=0;
}
signed main(){
int n,k,t;
cin>>n>>k>>t;
memset(up,0,sizeof(up));
memset(fr,0,sizeof(fr));
memset(to,0,sizeof(to));
memset(ou,0,sizeof(ou));
memset(dn,0,sizeof(dn));
int l[t],r[t],x[t];
for(int i=0;i<t;i++) cin>>l[i]>>r[i]>>x[i];
for(int i=0;i<t;i++){
l[i]--;
int p=0;
while(BS*p<=l[i]) p++;
eval(p-1);
for(int j=l[i];j<min(r[i],BS*p);j++){
if(ou[j/BS]) break;
if(dn[j]==x[i]-1) dn[j]=x[i];
else dn[j]=-1;
}
for(;BS*(p+1)<=r[i];p++){
if(ou[p]) continue;
if(up[p]){
if(to[p]==x[i]-1) to[p]=x[i];
else ou[p]=1;
}else{
up[p]=1;
fr[p]=x[i]-1;
to[p]=x[i];
}
}
eval(p);
for(int j=BS*p;j<r[i];j++){
if(ou[j/BS]) break;
if(dn[j]==x[i]-1) dn[j]=x[i];
else dn[j]=-1;
}
}
int p=0;
while(BS*p<n) eval(p++);
int ans=0;
for(int j=0;j<n;j++){
if(ou[j/BS]) continue;
ans+=dn[j]==k;
}
cout<<ans<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int>P;
struct segtree{
int n;
vector<P>lazy;
segtree(int sz){
n = 1; while( n < sz ) n<<=1;
lazy.resize(2*n-1);
for(int i=0;i<2*n-1;i++)lazy[i]=P(0,0);
}
void eval(int k,P x,int l,int r){
if(x.second==0)return ;
if(lazy[k].second==0)lazy[k]=x;
else if(lazy[k].second+1==x.first)lazy[k].second=x.second;
else lazy[k]=P(1e9,1e9);
}
void add(int a,int b,int x,int k=0,int l=0,int r=-1){
if(r==-1)r=n;
if(b<=l || r<=a)return;
if(a<=l&&r<=b){ eval(k,P(x,x),l,r); }
else{
eval(k*2+1,lazy[k],l,r);
eval(k*2+2,lazy[k],l,r);
lazy[k]=P(0,0);
add(a,b,x,2*k+1,l,(l+r)/2);
add(a,b,x,2*k+2,(l+r)/2,r);
}
}
};
#define r(i,n) for(int i=0;i<n;i++)
int main(){
int n,K,t,sum=0;
cin>>n>>K>>t;
segtree S(n);
r(i,t){
int l,r,x;
cin>>l>>r>>x; l--; r--;
S.add(l,r+1,x);
}
r(i,n)S.add(i,i+1,K+1);
r(i,S.n*2-1){
if(S.lazy[i].first==1 && S.lazy[i].second==K+1){
sum++;
}
}
cout<<sum<<endl;
}
|
#include <vector>
#include <algorithm>
#include <iostream>
#include <cstdio>
using namespace std;
const int BUCKET_SIZE = 512;
const int MAXN = 200010;
int N, K, T;
int node[MAXN], invalid_node[MAXN];
int bucket[BUCKET_SIZE], cons[BUCKET_SIZE], invalid_bucket[BUCKET_SIZE];
void lazy_update(int i) {
int sl = i*BUCKET_SIZE, sr = sl + BUCKET_SIZE;
// 区間更新値があれば適用
if(cons[i] > 0) {
// i: index for bucket
// k: index for node
for(int k=sl; k<sr; k++) {
if(bucket[i] - cons[i] != node[k]) {
invalid_node[k] = true;
}
else {
node[k] = bucket[i];
}
}
cons[i] = 0;
}
}
void update(int l, int r, int x) {
for(int i=0; i<BUCKET_SIZE; i++) {
int sl = i*BUCKET_SIZE, sr = sl + BUCKET_SIZE;
if(r <= sl or sr <= l) continue;
if(l <= sl and sr <= r) {
if(cons[i] > 0) {
// 区間更新されるような値が以前に存在
if(x - bucket[i] != 1) {
invalid_bucket[i] = true;
}
else {
bucket[i] = x;
cons[i]++;
}
}
else {
// 区間更新値がはじめてきた
bucket[i] = x;
cons[i] = 1;
}
}
else {
lazy_update(i);
for(int k=max(l,sl); k<min(r,sr); k++) {
if(x - node[k] != 1) {
invalid_node[k] = true;
}
else {
node[k] = x;
}
}
}
}
}
bool is_valid_node(int node_id) {
int bucket_id = node_id / BUCKET_SIZE;
lazy_update(bucket_id);
if(invalid_bucket[bucket_id]) return false;
if(invalid_node[node_id]) return false;
return node[node_id] == K;
}
int main() {
cin >> N >> K >> T;
for(int i=0; i<T; i++) {
int l, r, x; cin >> l >> r >> x; l--;
update(l, r, x);
}
int ans = 0;
for(int i=0; i<N; i++) {
ans += is_valid_node(i);
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) for(int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x) cerr << #x << " = " << (x) << endl;
using namespace std;
template<typename T>
ostream& operator << (ostream& os, vector<T>& v){
rep(i,v.size()){ os << v[i] << (i == v.size() - 1 ? "" : " "); } return os;
}
template<typename T>
istream& operator >> (istream& is, vector<T>& v){
for(T& x: v){ is >> x; } return is;
}
const int INF = 2000000000;
const int sqrtN = 512;
class sqdiv{
public:
int N, K;
vector<int> data;
vector<bool> lazy_flag;
vector<pair<int, int>> lazy_update;
sqdiv(int n){ //バケットサイズの変更
N = n;
K = (N + sqrtN - 1) / sqrtN;
data.assign(K * sqrtN, 0);
lazy_flag.assign(K, false);
lazy_update.assign(K, make_pair(0,0));
}
void eval(int k){
if(lazy_flag[k]){
lazy_flag[k] = false;
for(int i = k * sqrtN; i < (k + 1) * sqrtN; i++){
data[i] = data[i] + 1 == lazy_update[k].first ? lazy_update[k].second : INF;
}
}
}
void update(int x, int y, int a){
rep(k,K){
int l = k * sqrtN, r = (k + 1) * sqrtN;
if(r <= x || y <= l) continue;
if(x <= l && r <= y){
if(lazy_flag[k]){
lazy_update[k].second = lazy_update[k].second + 1 == a ? a : INF;
}else{
lazy_flag[k] = true;
lazy_update[k] = make_pair(a,a);
}
}else{
eval(k);
for(int i = max(x, l); i < min(y, r); i++){
data[i] = data[i] + 1 == a ? a : INF;
}
}
}
}
int find(int a){
int k = a / sqrtN;
eval(k);
return data[a];
}
};
int main(){
int n, k, t;
cin >> n >> k >> t;
sqdiv s(n);
rep(i,t){
int l, r, x;
cin >> l >> r >> x;
l--;
s.update(l, r, x);
//cout << s.data << endl;
}
int cnt = 0;
rep(i,n){
//cout << s.find(i) << ' ';
if(s.find(i) == k) cnt++;
}
//cout << endl;
cout << cnt << endl;
/*
* 1 -2 3 -4
*/
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int,int>pint;
typedef vector<int>vint;
typedef vector<pint>vpint;
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define all(v) (v).begin(),(v).end()
#define rep(i,n) for(int i=0;i<(n);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++)
template<class T,class U>inline void chmin(T &t,U f){if(t>f)t=f;}
template<class T,class U>inline void chmax(T &t,U f){if(t<f)t=f;}
const int SEG=1<<18;
pint seg[SEG*2];
pint put[SEG*2];
const pint none(-100,-100);
const pint fail(-10,-10);
inline void push(int k){
if(put[k]==none)return;
if(put[k]==fail){
seg[k]=fail;
}
if(seg[k].se+1==put[k].fi){
seg[k].se=put[k].se;
}
else{
seg[k]=fail;
}
if(k<SEG-1){
for(int i=1;i<=2;i++){
if(put[k*2+i]==none)put[k*2+i]=put[k];
else if(put[k*2+i]==fail)continue;
else if(put[k]==fail||put[k*2+i].se+1!=put[k].fi)put[k*2+i]=fail;
else put[k*2+i].se=put[k].se;
}
}
put[k]=none;
}
void update(int a,int b,pint s,int k=0,int l=0,int r=SEG){
push(k);
if(r<=a||b<=l)return;
if(a<=l&&r<=b){
put[k]=s;
push(k);
return;
}
update(a,b,s,k*2+1,l,(l+r)/2);
update(a,b,s,k*2+2,(l+r)/2,r);
}
signed main(){
int N,K;
cin>>N>>K;
rep(i,SEG*2){
seg[i]=pint(0,0);
put[i]=none;
}
int Q;cin>>Q;
while(Q--){
int a,b,c;
cin>>a>>b>>c;
a--;
update(a,b,pint(c,c));
}
rep(i,SEG*2)push(i);
int ans=0;
rep(i,N)if(seg[SEG-1+i]==pint(0,K))ans++;
cout<<ans<<endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
/*RMQ update:O(logN) query:O(lonN)*/
const int MAX_N = 1<<20;
struct data{
int l,r;
};
data dat[2*MAX_N-1];
int n;
//?????????
void init(int n_){
//????´???°n???2???????????????
n=1;
while(n<n_)n*=2;
for(int i=0;i<2*n-1;i++)
dat[i].l=dat[i].r=0;
}
//[a,b)
//query(a,b,0,0,n)
void query(int a,int b,int k,int l,int r,int x){
if(r<=a||b<=l)return;
if(a<=l&&r<=b){
if(!dat[k].l)dat[k].l=dat[k].r=x;
else if(dat[k].r+1==x)dat[k].r=x;
else dat[k].l=dat[k].r=-1;
}else{
if(dat[k].l){
if(!dat[k*2+1].l)dat[k*2+1].l=dat[k].l,dat[k*2+1].r=dat[k].r;
else if(dat[k*2+1].r+1==dat[k].l)dat[k*2+1].r=dat[k].r;
else dat[k*2+1].l=dat[k*2+1].r=-1;
if(!dat[k*2+2].l)dat[k*2+2].l=dat[k].l,dat[k*2+2].r=dat[k].r;
else if(dat[k*2+2].r+1==dat[k].l)dat[k*2+2].r=dat[k].r;
else dat[k*2+2].l=dat[k*2+2].r=-1;
dat[k].l=dat[k].r=0;
}
query(a,b,k*2+1,l,(l+r)/2,x);
query(a,b,k*2+2,(l+r)/2,r,x);
}
}
int main(){
int k,t,l,r,x;
cin>>n>>k>>t;
init(n);
for(int i=0;i<t;i++){
cin>>l>>r>>x; l--,r--;
query(l,r+1,0,0,n,x);
}
int ans=0;
for(int i=0;i<n;i++){
query(i,i+1,0,0,n,k+1);
if(dat[n+i-1].l==1&&dat[n+i-1].r==k+1)
ans++;
}
cout<<ans<<endl;
return 0;
} |
#include <cstdio>
#include <vector>
using namespace std;
struct SegmentTree {
int N;
vector<int> dl, dr;
SegmentTree(int N_)
{
N = 1;
while (N < N_) {
N *= 2;
}
dl.assign(2 * N - 1, -1);
dr.assign(2 * N - 1, -1);
for (int i = N - 1; i < 2 * N - 1; i++) {
dl[i] = 0; dr[i] = 1;
}
}
void eval(int k, int l, int r)
{
if (r == -1) {
return;
}
if (dr[k] == -1) {
dl[k] = l;
dr[k] = r;
} else if (dr[k] == l) {
dr[k] = r;
} else {
dl[k] = dr[k] = -2;
}
}
void update(int a, int b, int k, int l, int r, int x)
{
if (r <= a || b <= l) {
return;
}
if (a <= l && r <= b) {
eval(k, x, x + 1);
} else {
eval(k * 2 + 1, dl[k], dr[k]);
eval(k * 2 + 2, dl[k], dr[k]);
dl[k] = dr[k] = -1;
update(a, b, k * 2 + 1, l, (l + r) / 2, x);
update(a, b, k * 2 + 2, (l + r) / 2, r, x);
}
}
void update(int l, int r, int x)
{
update(l, r + 1, 0, 0, N, x);
}
int query(int K)
{
for (int i = 0; i < N - 1; i++) {
eval(i * 2 + 1, dl[i], dr[i]);
eval(i * 2 + 2, dl[i], dr[i]);
}
int cnt = 0;
for (int i = N - 1; i < 2 * N - 1; i++) {
if (dl[i] == 0 && dr[i] == K + 1) {
cnt += 1;
}
}
return cnt;
}
};
int main()
{
int N, K, T;
scanf("%d %d %d", &N, &K, &T);
SegmentTree seg(N);
for (int i = 0; i < T; i++) {
int l, r, x;
scanf("%d %d %d", &l, &r, &x);
seg.update(l - 1, r - 1, x);
}
printf("%d\n", seg.query(K));
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const int MAX_N = 1<<20;
struct data{
int l,r;
};
data dat[2*MAX_N-1];
int n;
void init(int n_){
n=1;
while(n<n_)n*=2;
for(int i=0;i<2*n-1;i++)
dat[i].l=dat[i].r=0;
}
void query(int a,int b,int k,int l,int r,int x){
if(r<=a||b<=l)return;
if(a<=l&&r<=b){
if(!dat[k].l)dat[k].l=dat[k].r=x;
else if(dat[k].r+1==x)dat[k].r=x;
else dat[k].l=dat[k].r=-1;
}else{
int k1=k*2+1,k2=k*2+2;
int L=dat[k].l,R=dat[k].r;
if(L){
if(!dat[k1].l)dat[k1].l=L,dat[k1].r=R;
else if(dat[k1].r+1==L)dat[k1].r=R;
else dat[k1].l=dat[k1].r=-1;
if(!dat[k2].l)dat[k2].l=L,dat[k2].r=R;
else if(dat[k2].r+1==L)dat[k2].r=R;
else dat[k2].l=dat[k2].r=-1;
dat[k].l=dat[k].r=0;
}
query(a,b,k1,l,(l+r)/2,x);
query(a,b,k2,(l+r)/2,r,x);
}
}
int main(){
int k,t,l,r,x;
cin>>n>>k>>t;
init(n);
for(int i=0;i<t;i++){
scanf("%d%d%d",&l,&r,&x);
l--,r--;
query(l,r+1,0,0,n,x);
}
int ans=0;
for(int i=0;i<n;i++){
query(i,i+1,0,0,n,k+1);
if(dat[n+i-1].l==1&&dat[n+i-1].r==k+1)
ans++;
}
cout<<ans<<endl;
return 0;
} |
#include <bits/stdc++.h>
const int N = 200005;
int id[N], val[N], min[N], max[N], add[N], pri[N], n, k, t, ans;
int lc[N], rc[N];
void setadd(int x, int v) {
min[x] += v, max[x] += v, add[x] += v, val[x] += v;
}
void pushdown(int x) {
if (add[x]) setadd(lc[x], add[x]), setadd(rc[x], add[x]), add[x] = 0;
}
void pushup(int x) {
min[x] = max[x] = val[x];
if (lc[x]) min[x] = std::min(min[x], min[lc[x]]), max[x] = std::max(max[x], max[lc[x]]);
if (rc[x]) min[x] = std::min(min[x], min[rc[x]]), max[x] = std::max(max[x], max[rc[x]]);
}
void split(int now, int k, int &x, int &y) {
if (!now) return void(x = y = 0);
pushdown(now);
if (id[now] <= k)
x = now, split(rc[x], k, rc[x], y);
else
y = now, split(lc[y], k, x, lc[y]);
pushup(now);
}
int merge(int x, int y) {
if (!x || !y) return x | y;
if (pri[x] < pri[y])
return pushdown(x), rc[x] = merge(rc[x], y), pushup(x), x;
else
return pushdown(y), lc[y] = merge(x, lc[y]), pushup(y), y;
}
int root;
void dfs(int &x, int k) {
if (!x) return;
if (min[x] == max[x] && min[x] == k - 1) return setadd(x, 1);
pushdown(x);
dfs(lc[x], k), dfs(rc[x], k);
if (val[x] == k - 1) return val[x] += 1, pushup(x);
x = merge(lc[x], rc[x]);
}
void count(int x) {
if (!x) return;
pushdown(x);
if (val[x] == k) ++ans;
count(lc[x]), count(rc[x]);
}
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::srand(std::time(0));
std::cin >> n >> k >> t;
for (int i = 1; i <= n; ++i)
pri[i] = std::rand(), id[i] = i, pushup(i), root = merge(root, i);
for (int i = 1; i <= t; ++i) {
int l, r, g;
std::cin >> l >> r >> g;
int a, b;
split(root, r, root, b);
split(root, l - 1, a, root);
dfs(root, g);
root = merge(a, merge(root, b));
}
count(root);
std::cout << ans << '\n';
return 0;
}
|
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
#include<complex>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
typedef pair<int, int>P;
typedef pair<int, bool> sP;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef pair<ll, ll> LP;
typedef vector<ll> vec;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-5;
const ld pi = acos(-1.0);
typedef vector<vector<ll>> mat;
typedef vector<ll> vec;
struct SegT {
private:
int n; vector<int> node;vector<P> lazy;
vector<bool> valid,avalid;
const ll init_c = INF;
public:
SegT(int sz) {
n = 1;
while (n < sz)n <<= 1;
node.resize(2 * n - 1, 0);
lazy.resize(2 * n - 1, { -1,-1 });
valid.resize(2 * n - 1, true);
avalid.resize(2 * n - 1, true);
}
bool lazymerge(P &fr,P &to) {
if (to.first < 0) {
to = fr;
}
else {
if (to.second + 1 == fr.first) {
to.second = fr.second;
}
else {
return false;
}
}
return true;
}
void eval(int k, int l, int r) {
if (lazy[k].first >= 0) {
//cout << k << " " << node[k] << " " << lazy[k].first << " " << lazy[k].second << endl;
if (node[k] + 1 == lazy[k].first) {
node[k] = lazy[k].second;
}
else {
avalid[k] = false;
}
if (r - l > 1) {
if (!lazymerge(lazy[k], lazy[2 * k + 1])) {
valid[2 * k + 1] = false;
}
if (!lazymerge(lazy[k], lazy[2 * k + 2])) {
valid[2 * k + 2] = false;
}
}
}
lazy[k] = { -1,-1 };
}
void add(int x, int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)r = n;
eval(k, l, r);
if (r <= a || b <= l)return;
if (a <= l && r <= b) {
lazy[k] = { x,x };
eval(k, l, r);
}
else {
add(x, a, b, k * 2 + 1, l, (l + r) / 2);
add(x, a, b, k * 2 + 2, (l + r) / 2, r);
}
}
void clear_lazy() {
queue<pair<int, P>> q; q.push({ 0,{0,n} });
while (!q.empty()) {
int k = q.front().first;
int l = q.front().second.first;
int r = q.front().second.second;
q.pop();
eval(k, l, r);
if (r - l > 1) {
int mid = (l + r) / 2;
q.push({ 2 * k + 1,{l,mid} });
q.push({ 2 * k + 2,{mid,r} });
if (!valid[k]) {
valid[2 * k + 1] = false;
valid[2 * k + 2] = false;
}
}
}
}
int ans(int sz,int k) {
int res = 0;
rep(i, sz) {
if (!avalid[i + n - 1]) {
valid[i + n - 1] = false;
}
//cout << valid[i + n - 1] << " " << node[i + n - 1] << endl;
if (valid[i + n - 1] && node[i + n - 1] == k)res++;
}
return res;
}
};
void solve() {
int n, k; cin >> n >> k;
int t; cin >> t;
SegT st(n);
rep(i, t) {
int l, r, x; cin >> l >> r >> x; l--; r--;
st.add(x, l, r+1);
}
st.clear_lazy();
int ans = st.ans(n, k);
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
//cout << fixed << setprecision(7);
//init();
solve();
//stop
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N,K,T;
const int B = 512;
int bfr[200010/B+1], aft[200010/B+1];
int val[200010/B*B+B];
void sync(int b){
if(bfr[b] == -1) return;
for(int i = b*B; i < (b+1)*B; ++i){
val[i] = (val[i] == bfr[b]) ? aft[b] : -2;
}
bfr[b] = -1;
aft[b] = -1;
}
void naive(int l, int r, int x){
for(int i = l; i < r; ++i){
val[i] = (val[i] == x-1) ? x : -2;
}
}
void block(int l, int r, int x){
l /= B;
r /= B;
while(l < r){
if(aft[l] != -1){
aft[l] = (aft[l] == x-1) ? x : -2;
} else {
bfr[l] = x-1;
aft[l] = x;
}
++l;
}
}
void exec(int l, int r, int x){
if(l/B == r/B){
sync(l/B);
naive(l,r,x);
} else {
if(l%B){
sync(l/B);
naive(l, l-l%B+B, x);
l = l-l%B+B;
}
if(r%B){
sync(r/B);
naive(r-r%B, r, x);
r = r-r%B;
}
block(l,r,x);
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
cin >> N >> K;
cin >> T;
memset(bfr, -1, sizeof bfr);
memset(aft, -1, sizeof aft);
while(N%B) ++N;
for(int it = 0; it < T; ++it){
int l,r,x;
cin >> l >> r >> x;
--l;
exec(l,r,x);
}
for(int i = 0; i < N/B; ++i){
sync(i);
}
cout << count(val, val+N, K) << endl;
} |
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
struct Info{
int start,end;
};
int N = 1;
Info* donut;
void init(int first_N){
while(N < first_N)N *= 2;
}
void update(int update_left,int update_right,int new_value_start,int new_value_end,int node_id,int node_left,int node_right){
if(update_right < node_left || update_left > node_right){
return;
}
else if(update_left <= node_left && update_right >= node_right){
if(donut[node_id].start == 0 && donut[node_id].end == 0){
donut[node_id].start = new_value_start;
donut[node_id].end = new_value_end;
}else{
if(donut[node_id].end+1 == new_value_start){
donut[node_id].end = new_value_end;
}else{
donut[node_id].start = BIG_NUM;
donut[node_id].end = BIG_NUM;
}
}
}else{
if(donut[node_id].start != 0){
update(node_left,node_right,donut[node_id].start,donut[node_id].end,2*node_id+1,node_left,(node_left+node_right)/2);
update(node_left,node_right,donut[node_id].start,donut[node_id].end,2*node_id+2,(node_left+node_right)/2+1,node_right);
}
donut[node_id].start = 0;
donut[node_id].end = 0;
update(update_left,update_right,new_value_start,new_value_end,2*node_id+1,node_left,(node_left+node_right)/2);
update(update_left,update_right,new_value_start,new_value_end,2*node_id+2,(node_left+node_right)/2+1,node_right);
}
}
void merge_range(int node_id){
int loc = node_id+N-1;
int left = donut[loc].start,right = donut[loc].end;
int parent_id = (loc-1)/2;
while(true){
if(donut[parent_id].start == 0 && donut[parent_id].end == 0){
//Do nothing
}else{
if(left == 0 && right == 0){
left = donut[parent_id].start;
right = donut[parent_id].end;
}else{
if(right+1 == donut[parent_id].start){
right = donut[parent_id].end;
}else{
left = BIG_NUM;
right = BIG_NUM;
break;
}
}
}
if(parent_id == 0)break;
parent_id = (parent_id-1)/2;
};
donut[loc].start = left,donut[loc].end = right;
}
int main(){
int first_N,K,T;
scanf("%d %d",&first_N,&K);
scanf("%d",&T);
init(first_N);
donut = new Info[2*N-1];
for(int i = 0; i <= 2*N-2; i++){
donut[i].start = 0;
donut[i].end = 0;
}
int left,right,task_id;
for(int loop = 0; loop < T; loop++){
scanf("%d %d %d",&left,&right,&task_id);
left--;
right--;
update(left,right,task_id,task_id,0,0,N-1);
}
for(int i = 0; i < first_N; i++)merge_range(i);
int ans = 0;
for(int i = 0; i < first_N; i++){
if(donut[N-1+i].start == 1 && donut[N-1+i].end == K)ans++;
}
printf("%d\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define for_(i,a,b) for(int i=(a);i<(b);++i)
typedef pair< int, int > pii;
class Decoration {
private:
int n;
vector< pii > deco, job;
int toLeft(int k) { return (k << 1) + 1; }
int toRight(int k) { return (k << 1) + 2; }
int center(int l, int r) { return (l + r) >> 1; }
pii mixDeco(pii fp, pii sp) {
if (fp.first == 0) return sp;
if (sp.first == 0) return fp;
if (fp.first < 0 || sp.first < 0) return pii(-1,-1);
if (fp.second + 1 == sp.first) return pii(fp.first, sp.second);
return pii(-1, -1);
}
void lazyEval(int k, int l, int r) {
deco[k] = mixDeco(deco[k], job[k]);
if (k < n-1) {
job[toLeft(k)] = mixDeco(job[toLeft(k)], job[k]);
job[toRight(k)] = mixDeco(job[toRight(k)], job[k]);
}
job[k] = pii(0,0);
}
void addDeco(int a, int b, int x, int k, int l, int r) {
lazyEval(k, l, r);
if (r <= a || b <= l) return;
if (a <= l && r <= b) {
job[k] = pii(x, x);
lazyEval(k, l, r);
return;
}
addDeco(a, b, x, toLeft(k), l, center(l, r));
addDeco(a, b, x, toRight(k), center(l, r), r);
}
pii getDeco(int a, int k, int l, int r) {
lazyEval(k, l, r);
if (l == a && r == a+1) return deco[k];
int c = center(l, r);
if (a < c) return getDeco(a, toLeft(k), l, c);
else return getDeco(a, toRight(k), c, r);
}
public:
Decoration(int __n) {
for (n=1; n<__n; n<<=1);
deco.assign(2*n, pii(0,0));
job.assign(2*n, pii(0,0));
}
void addDeco(int a, int b, int x) { addDeco(a, b, x, 0, 0, n); }
pii getDeco(int a) { return getDeco(a, 0, 0, n); }
};
int main() {
int N, K;
cin >> N >> K;
Decoration deco(N);
int T;
cin >> T;
for_(i,0,T) {
int l, r, x;
cin >> l >> r >> x;
deco.addDeco(l-1, r, x);
}
int ans = 0;
for_(i,0,N) {
pii p = deco.getDeco(i);
if (p.first == 1 && p.second == K) ++ans;
}
cout << ans << endl;
} |
#include <bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
const function<P(P, P)> minQ = [](P l, P r) { return min(l, r); };
template <typename T>
class LazySegmentTree {
using func_t = function<T(T, T)>;
const int n;
const T id1, id2;
func_t merge;
func_t change;
vector<T> data, lazy;
int size(int n) {
int res = 1;
while (res < n) res <<= 1;
return res;
}
void propa(int node) {
if (lazy[node] == id2) return;
if (node < n) {
lazy[node * 2] = change(lazy[node * 2], lazy[node]);
lazy[node * 2 + 1] = change(lazy[node * 2 + 1], lazy[node]);
}
data[node] = change(data[node], lazy[node]);
lazy[node] = id2;
}
void suc(int l, int r, int node, int lb, int ub, T val) {
if (ub <= l || r <= lb) return;
propa(node);
if (l <= lb && ub <= r) {
lazy[node] = val;
return;
}
int c = (lb + ub) / 2;
suc(l, r, node * 2, lb, c, val);
suc(l, r, node * 2 + 1, c, ub, val);
data[node] = merge(change(data[node * 2], lazy[node * 2]), change(data[node * 2 + 1], lazy[node * 2 + 1]));
}
T sub(int l, int r, int node, int lb, int ub) {
if (ub <= l || r <= lb) return id1;
propa(node);
if (l <= lb && ub <= r) {
return data[node];
}
int c = (lb + ub) / 2;
return merge(sub(l, r, node * 2, lb, c), sub(l, r, node * 2 + 1, c, ub));
}
public:
LazySegmentTree(int n_, T id1_, T id2_, func_t merge_, func_t change_)
: n(size(n_)), id1(id1_), id2(id2_), merge(merge_), change(change_), data(n * 2, id1), lazy(n * 2, id2) {}
void update(int l, int r, T val) {
suc(l, r + 1, 1, 0, n, val);
}
T find(int l) {
sub(l, l + 1, 1, 0, n);
return data[l + n];
}
};
int main()
{
cin.sync_with_stdio(false);
int N, K, T;
cin >> N >> K >> T;
LazySegmentTree<P> lst(N, P(0, 0), P(-1, -1), minQ, [](P l, P r) {
if (l == P(-1, -1)) return r;
if (r == P(-1, -1)) return l;
if (l == P(-2, -2) || r == P(-2, -2)) return P(-2, -2);
return l.second == r.first ? P(l.first, r.second) : P(-2, -2);
});
for (int i = 0, l, r, x; i < T; i++) {
cin >> l >> r >> x; l--; r--;
lst.update(l, r, P(x - 1, x));
}
int res = 0;
for (int i = 0; i < N; i++) {
if (lst.find(i) == P(0, K)) {
res++;
}
}
cout << res << endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
/*RMQ update:O(logN) query:O(lonN)*/
const int MAX_N = 1<<20;
struct data{
int l,r;
};
data dat[2*MAX_N-1];
int n;
//?????????
void init(int n_){
//????´???°n???2???????????????
n=1;
while(n<n_)n*=2;
for(int i=0;i<2*n-1;i++)
dat[i].l=dat[i].r=0;
}
//[a,b)
//query(a,b,0,0,n)
void query(int a,int b,int k,int l,int r,int x){
if(r<=a||b<=l)return;
if(a<=l&&r<=b){
if(!dat[k].l)dat[k].l=dat[k].r=x;
else if(dat[k].r+1==x)dat[k].r=x;
else dat[k].l=dat[k].r=-1;
}else{
if(dat[k].l){
if(!dat[k*2+1].l)dat[k*2+1].l=dat[k].l,dat[k*2+1].r=dat[k].r;
else if(dat[k*2+1].r+1==dat[k].l)dat[k*2+1].r=dat[k].r;
else dat[k*2+1].l=dat[k*2+1].r=-1;
if(!dat[k*2+2].l)dat[k*2+2].l=dat[k].l,dat[k*2+2].r=dat[k].r;
else if(dat[k*2+2].r+1==dat[k].l)dat[k*2+2].r=dat[k].r;
else dat[k*2+2].l=dat[k*2+2].r=-1;
dat[k].l=dat[k].r=0;
}
query(a,b,k*2+1,l,(l+r)/2,x);
query(a,b,k*2+2,(l+r)/2,r,x);
}
}
int main(){
int k,t,l,r,x;
cin>>n>>k>>t;
init(n);
for(int i=0;i<t;i++){
scanf("%d%d%d",&l,&r,&x);
l--,r--;
query(l,r+1,0,0,n,x);
}
int ans=0;
for(int i=0;i<n;i++){
query(i,i+1,0,0,n,k+1);
if(dat[n+i-1].l==1&&dat[n+i-1].r==k+1)
ans++;
}
cout<<ans<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
using T = tuple<int, int, int>;// l,r,k
using P = pair<int, int>;// t, k
vector<P> in[200000];
vector<P> out[200000];
int cnt[200010];
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
#ifdef LOCAL
std::ifstream ifs("in");
std::cin.rdbuf(ifs.rdbuf());
#endif
int N, K, Q;
cin >> N >> K >> Q;
for(int i = 0; i < Q; i++){
int l, r, k;
cin >> l >> r >> k;
l--, r--;
in[l].push_back({ i, k });
out[r].push_back({ i, k });
}
int ans = 0, NG = 0;
set<P> s;
map<int, int> cm;
cm[0] = K;
for(int i = 0; i < N; i++){
for(auto x : in[i]){
s.insert(x);
auto it = s.find(x);
if(it != s.begin()){
auto pre = prev(it);
if(pre->second >= it->second) NG++;
auto nxt = next(it);
if(nxt != s.end()){
if(pre->second >= nxt->second) NG--;
}
}
{
auto nxt = next(it);
if(nxt != s.end()){
if(it->second >= nxt->second) NG++;
}
}
cm[cnt[x.second]]--;
cnt[x.second]++;
cm[cnt[x.second]]++;
}
if(NG == 0 && cm[1] == K && s.size() == K){
ans++;
}
for(auto x : out[i]){
auto it = s.find(x);
if(it != s.begin()){
auto pre = prev(it);
if(pre->second >= it->second) NG--;
auto nxt = next(it);
if(nxt != s.end()){
if(pre->second >= nxt->second) NG++;
}
}
{
auto nxt = next(it);
if(nxt != s.end()){
if(it->second >= nxt->second) NG--;
}
}
s.erase(x);
cm[cnt[x.second]]--;
cnt[x.second]--;
cm[cnt[x.second]]++;
}
}
cout << ans << endl;
} |
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<functional>
#include<assert.h>
#include<numeric>
using namespace std;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
using ll = long long;
const int inf=1e9+7;
const ll longinf=1LL<<60 ;
const ll mod=1e9+7 ;
template<typename T, typename S>
struct LazySegmentTree{
private:
int n;
vector<T> node;
vector<S> lazy;
T E0;
S E1;
inline void updatef(S& lazy,S& value){
//lazy += value;
lazy.first = lazy.first * value.first ;
lazy.second = (lazy.second * value.first + value.second );
//lazy = max(lazy, value);
//lazy = min(lazy, value);
}
inline void calculatef(T& node,S& lazy,int len){
//node += lazy * len; //区間sumはこっち
// node += lazy ; //区間maxとか
node = lazy.first * node + lazy.second ;
}
inline T queryf(T& x,T& y){
//return x + y;
//return x * y;
//return max(x, y);
return x+y;
}
public:
LazySegmentTree(int sz,T nodeE,S lazyE ):E0(nodeE), E1(lazyE){
n=1;
while(n<sz)n<<=1;
node.resize(2*n-1,E0);
lazy.resize(2*n-1,E1);
}
LazySegmentTree(vector<T>& v,T E0,S E1 ):E0(E0),E1(E1){
n=1;
int sz=v.size();
while(n<sz)n<<=1;
node.resize(2*n-1,E0);
lazy.resize(2*n-1,E1);
rep(i,sz)node[i+n-1] = v[i];
for(int i=n-2; i>=0; --i){
node[i] = queryf(node[2*i+1],node[2*i+2]);
}
}
void eval(int k,int l,int r){
if(lazy[k]==E1)return ;
calculatef(node[k], lazy[k], r-l);
if(r-l>1){
updatef(lazy[2*k+1], lazy[k]);
updatef(lazy[2*k+2], lazy[k]);
}
lazy[k]=E1;
}
void update(int a, int b, S x,int k=0,int l=0,int r=-1){
if(r<0)r=n;
eval(k,l,r);
if(r<=a||b<=l)return;
if(a<=l&&r<=b){
updatef(lazy[k], x);
eval(k,l,r);
}
else {
update(a,b,x,2*k+1,l,(l+r)/2);
update(a,b,x,2*k+2,(l+r)/2,r);
node[k]=queryf(node[2*k+1], node[2*k+2]);
}
}
T query(int a,int b,int k=0,int l=0,int r=-1){
if(r<0)r=n;
eval(k,l,r);
if(r<=a||b<=l)return E0;
if(a<=l&&r<=b)return node[k];
T xl=query(a,b,2*k+1,l,(l+r)/2);
T xr=query(a,b,2*k+2,(l+r)/2,r);
return queryf(xl, xr);
}
};
using ull = unsigned long long;
int main(){
int n,k,t;
cin>>n>>k>>t;
LazySegmentTree<ull,pair<ull,ull>> sg(n,0,{1,0});
const ull p = mod;
while(t--){
int l, r, x;
cin>>l>>r>>x;
sg.update(l-1,r,{mod,x});
}
ull ok = 0;
rep(i,k){
ok = ok * p + (i+1);
}
int ans=0;
rep(i,n){
if(sg.query(i,i+1)==ok)++ans;
}
cout<<ans<<endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <map>
using namespace std;
typedef pair<int, int>P;
P tree[524300];
void update(int id, int d, int l, int r, int a, int b){
int L = (id<<d) - 262144;
int R = (id<<d) + (1<<d) - 1 - 262144;
if(r < L || R < l)return;
if(l<=L && R<=r){
if(tree[id].first==0){
tree[id].first = a;
tree[id].second = b;
//cout<<L<<" "<<R<<" -> "<<tree[id].first<<" "<<tree[id].second<<endl;
}
else if(tree[id].second+1==a){
tree[id].second = b;
//cout<<L<<" "<<R<<" -> "<<tree[id].first<<" "<<tree[id].second<<endl;
}
else{
tree[id] = P(999999, 999999);
//cout<<L<<" "<<R<<" -> "<<tree[id].first<<" "<<tree[id].second<<endl;
}
}
else if(tree[id].first==999999){
}
else if(tree[id].first==0){
update(id*2, d-1, l, r, a, b);
update(id*2+1, d-1, l, r, a, b);
}
else{
update(id*2, d-1,L,R,tree[id].first,tree[id].second);
update(id*2+1, d-1,L,R,tree[id].first,tree[id].second);
tree[id].first = 0;
tree[id].second = 0;
//cout<<L<<" "<<R<<" -> "<<tree[id].first<<" "<<tree[id].second<<endl;
update(id*2, d-1, l, r, a, b);
update(id*2+1, d-1, l, r, a, b);
}
}
P check(int id, P p){
if(id==0)return p;
if(tree[id].first!=0){
//cout<<tree[id].first<<" "<<tree[id].second<<endl;
if(p.first==0){
p=tree[id];
}
else if(p.second+1==tree[id].first){
p.second=tree[id].second;
}
else{
p = P(999999, 999999);
}
}
return check(id/2, p);
}
int main(){
int N, K, T;
cin>>N>>K>>T;
for(int i=0;i<T;i++){
int l, r, x;
cin>>l>>r>>x;
update(1, 18, l, r, x, x);
}
int ans = 0;
for(int i=1;i<=N;i++){
P p = check(262144+i, P(0, 0));
//cout<<i<<" : "<<p.first<<" "<<p.second<<endl;
if(p.first==1 && p.second==K)ans++;
}
cout<<ans<<endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
using namespace std;
typedef pair<int, int> pii;
const pii invalid(-100, -100);
const pii neutral(-1, -1);
pii merge(const pii &a, const pii &b){
if(a.second + 1 == b.first){
return pii(a.first, b.second);
}
return invalid;
}
int main(){
int n,k,t;
cin >> n >> k >> t;
const int siz = 512;
vector<pii> bucket(n/siz + 1, neutral);
vector<pii> cell(n, pii(0, 0));
for(int i=0; i<t; i++){
int l,r,x;
cin >> l >> r >> x;
l--; //[l, r), 0-idx
int lmin=l-l%siz, rmin=r-1-(r-1)%siz;
int lmax=lmin+siz, rmax=rmin+siz;
vector<pii> range{pii(lmin, lmax)};
if(lmin < rmin){
range.emplace_back(rmin, rmax);
}
for(auto ra: range){
for(int j=ra.first; j<ra.second; j++){
if(bucket[j/siz] != neutral){
cell[j] = merge(cell[j], bucket[j/siz]);
}
if(l<=j and j<r){
cell[j] = merge(cell[j], pii(x, x));
}
}
bucket[ra.first/siz] = neutral;
}
for(int j=lmax/siz; j<rmin/siz; j++){
if(bucket[j] == neutral){
bucket[j] = pii(x, x);
}else{
bucket[j] = merge(bucket[j], pii(x, x));
}
}
}
int ans = 0;
for(int i=0; i<n; i++){
if(bucket[i/siz] != neutral){
cell[i] = merge(cell[i], bucket[i/siz]);
}
if(cell[i] == pii(0, k)){
ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define reps(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
template<class T1, class T2> void chmin(T1 &a, T2 b){if(a>b)a=b;}
template<class T1, class T2> void chmax(T1 &a, T2 b){if(a<b)a=b;}
typedef pair<int, int> Pi;
typedef tuple<int, int, int> Ti;
typedef vector<int> vint;
const int inf = 1LL << 55;
const int mod = 1e9 + 7;
struct SegmentTree {
vector<Pi> data;
vector<Pi> lazy;
int sz;
SegmentTree(int n) {
sz = 1; while(sz < n) sz <<= 1;
data.resize(2*sz-1, Pi(0, 0));
lazy.resize(2*sz-1, Pi(0, 0));
}
void merge(Pi& p, Pi q) {
//cout<<p.second<<" "<<q.first<<endl;
if(p.second == q.first-1) {
if(p.first == 0) p = q;
else p.second = q.second;
} else {
p = Pi(-1, -1);
}
}
void merge2(Pi& p, Pi q) {
if(p.first == 0) p = q;
else if(p.second == q.first-1) p.second = q.second;
else p = Pi(-1, -1);
}
void push(int k, int l, int r) {
if(lazy[k].first) {
merge(data[k], lazy[k]);
if(r - l > 1) {
merge2(lazy[2*k+1], lazy[k]);
merge2(lazy[2*k+2], lazy[k]);
}
if(lazy[k].first != -1) lazy[k] = Pi(0, 0);
}
}
void update(int a, int b, int x, int k, int l, int r, bool flag) {
push(k, l, r);
if(r <= a || b <= l) return;
if(a <= l && r <= b) {
//cout<<a<<" "<<b<<" "<<x<<" "<<l<<" "<<r<<endl;
if(flag) merge2(lazy[k], Pi(x, x));
push(k, l, r);
return;
}
update(a, b, x, 2*k+1, l, (l+r)/2, flag);
update(a, b, x, 2*k+2, (l+r)/2, r, flag);
}
void update(int a, int b, int x, bool flag = true) {
update(a, b, x, 0, 0, sz, flag);
}
int query(int a, int b, int x, int k, int l, int r) {
push(k, l, r);
if(r <= a || b <= l) return 0;
if(a <= l && r <= b) return data[k].first == 1 && data[k].second == x;
return query(a, b, x, 2*k+1, l, (l+r)/2) + query(a, b, x, 2*k+2, (l+r)/2, r);
}
int query(int a, int b, int x) {
return query(a, b, x, 0, 0, sz);
}
};
signed main()
{
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
int N, K, T;
cin >> N >> K >> T;
SegmentTree seg(N);
rep(i, T) {
int l, r, x;
cin >> l >> r >> x;
--l;
seg.update(l, r, x);
}
int ans = 0;
rep(i, N) {
ans += seg.query(i, i+1, K);
}
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int N,K,T;
const int B = 512;
int from[200010/B+1], to[200010/B+1];
int val[200010/B*B+B];
void sync(int b){
if(from[b] == -1) return;
for(int i = b*B; i < (b+1)*B; ++i){
if(val[i] == from[b]){
val[i] = to[b];
} else {
val[i] = -2;
}
}
from[b] = -1;
to[b] = -1;
}
void naive(int l, int r, int x){
for(int i = l; i < r; ++i){
val[i] = (val[i] == x-1) ? x : -2;
}
}
void block(int l, int r, int x){
//assert(l%B == 0 && r%B == 0);
l /= B;
r /= B;
while(l < r){
if(to[l] != -1){
to[l] = (to[l] == x-1) ? x : -2;
} else {
from[l] = x-1;
to[l] = x;
}
++l;
}
}
void exec(int l, int r, int x){
if(l/B == r/B){
sync(l/B);
naive(l,r,x);
} else {
if(l%B){
sync(l/B);
naive(l, l-l%B+B, x);
l = l-l%B+B;
}
if(r%B){
sync(r/B);
naive(r-r%B, r, x);
r = r-r%B;
}
block(l,r,x);
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
cin >> N >> K;
cin >> T;
memset(from, -1, sizeof from);
memset(to, -1, sizeof to);
while(N%B) ++N;
for(int it = 0; it < T; ++it){
int l,r,x;
cin >> l >> r >> x;
--l;
exec(l,r,x);
}
for(int i = 0; i < N/B; ++i){
sync(i);
}
cout << count(val, val+N, K) << endl;
} |
#include<cstdio>
#include<algorithm>
using namespace std;
#define MAXN 200010
#define INF 1000000000
struct node
{
int l,r,mx,mn,tg;
}t[MAXN*4];
int cnt,n,k,rt,tm,ans;
void Build(int &i,int l,int r)
{
if(i==0) i=++cnt;
if(l==r)
{
t[i].l=t[i].r=t[i].mx=t[i].mn=t[i].tg=0;
return;
}
int mid=(l+r)>>1;
Build(t[i].l,l,mid);
Build(t[i].r,mid+1,r);
}
void PushDown(int i)
{
if(t[i].tg)
{
int l=t[i].l,r=t[i].r,c=t[i].tg;
if(l) t[l].tg+=c,t[l].mx+=c,t[l].mn+=c;
if(r) t[r].tg+=c,t[r].mx+=c,t[r].mn+=c;
t[i].tg=0;
}
}
void PushUp(int i)
{
t[i].mx=max(t[t[i].l].mx,t[t[i].r].mx);
t[i].mn=min(t[t[i].l].mn,t[t[i].r].mn);
}
void Solve(int &i,int l,int r,int x)
{
if(i==0) return;
if(t[i].mn==x-1&&t[i].mx==x-1)
{
t[i].tg++;t[i].mx++,t[i].mn++;
return;
}
if(t[i].mn>=x&&t[i].mx<x-1)
{
i=0;
return;
}
PushDown(i);
int mid=(l+r)>>1;
Solve(t[i].l,l,mid,x);
Solve(t[i].r,mid+1,r,x);
PushUp(i);
if(t[i].l==0&&t[i].r==0) i=0;
}
void Modify(int &i,int l,int r,int L,int R,int x)
{
if(i==0) return;
if(L<=l&&r<=R)
{
Solve(i,l,r,x);
return;
}
PushDown(i);
int mid=(l+r)>>1;
if(L<=mid) Modify(t[i].l,l,mid,L,R,x);
if(R>mid) Modify(t[i].r,mid+1,r,L,R,x);
PushUp(i);
if(t[i].l==0&&t[i].r==0) i=0;
}
void dfs(int i,int l,int r)
{
if(i==0||t[i].mx<k) return;
if(l==r)
{
if(t[i].mx==k) ans++;
return;
}
PushDown(i);
int mid=(l+r)>>1;
dfs(t[i].l,l,mid);
dfs(t[i].r,mid+1,r);
}
int main()
{
t[0].mx=-INF;
t[0].mn=INF;
t[0].l=t[0].r=t[0].tg=0;
scanf("%d%d%d",&n,&k,&tm);
Build(rt,1,n);
int l,r,x;
while(tm--)
{
scanf("%d%d%d",&l,&r,&x);
Modify(rt,1,n,l,r,x);
}
dfs(rt,1,n);
printf("%d\n",ans);
}
|
#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
typedef unsigned int uint;
inline char nc(){
static char buf[100000],*p1=buf,*p2=buf;
return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
inline void read(int &x){
char c=nc(),b=1;
for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}
const int N=200005;
const uint seed=233333;
struct abcd{
uint a,b;
abcd(uint a=1,uint b=0):a(a),b(b) { }
bool one() { return a==1 && b==0; }
void add(abcd B){
uint _a=a,_b=b;
a=B.a*_a; b=B.a*_b+B.b;
}
}T[N<<2];
inline void modify(int x,int l,int r,int ql,int qr,abcd t){
if (ql<=l && r<=qr){
T[x].add(t);
return;
}
if (!T[x].one())
T[x<<1].add(T[x]),T[x<<1|1].add(T[x]),T[x]=abcd();
int mid=(l+r)>>1;
if (ql<=mid) modify(x<<1,l,mid,ql,qr,t);
if (qr>mid) modify(x<<1|1,mid+1,r,ql,qr,t);
}
uint Hash[N];
inline void query(int x,int l,int r){
if (l==r){
Hash[l]=T[x].b;
return;
}
if (!T[x].one())
T[x<<1].add(T[x]),T[x<<1|1].add(T[x]),T[x]=abcd();
int mid=(l+r)>>1;
query(x<<1,l,mid);
query(x<<1|1,mid+1,r);
}
int n,K;
int main(){
int T,l,r,x;
read(n); read(K);
read(T);
while (T--){
read(l); read(r); read(x);
modify(1,1,n,l,r,abcd(seed,x));
}
query(1,1,n);
uint h=0;
for (int i=1;i<=K;i++) h=h*seed+i;
int ans=0;
for (int i=1;i<=n;i++)
if (Hash[i]==h)
ans++;
printf("%d\n",ans);
return 0;
} |
#include <iostream>
#include <vector>
#include <set>
void solve() {
int n, k, t;
std::cin >> n >> k >> t;
std::vector<std::vector<int>> ls(n), rs(n);
std::vector<int> xs(t + 2);
xs[0] = 0;
for (int i = 1; i <= t; ++i) {
int l, r;
std::cin >> l >> r >> xs[i];
ls[--l].push_back(i);
rs[--r].push_back(i);
}
xs[t + 1] = k + 1;
std::set<int> ts{0, t + 1};
int out = 1, ans = 0;
for (int i = 0; i < n; ++i) {
for (auto x : ls[i]) {
auto it = ts.lower_bound(x);
int nxt = *it;
--it;
int prev = *it;
if (xs[nxt] - xs[prev] != 1) --out;
if (xs[x] - xs[prev] != 1) ++out;
if (xs[nxt] - xs[x] != 1) ++out;
ts.insert(x);
}
if (out == 0) ++ans;
for (auto x : rs[i]) {
ts.erase(x);
auto it = ts.lower_bound(x);
int nxt = *it;
--it;
int prev = *it;
if (xs[x] - xs[prev] != 1) --out;
if (xs[nxt] - xs[x] != 1) --out;
if (xs[nxt] - xs[prev] != 1) ++out;
}
}
std::cout << ans << std::endl;
}
int main() {
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N,K,T;
const int B = 500;
int from[200010/B+1], to[200010/B+1];
int val[200010/B*B+B];
void sync(int b){
if(from[b] == -1) return;
for(int i = b*B; i < (b+1)*B; ++i){
if(val[i] == from[b]){
val[i] = to[b];
} else {
val[i] = -2;
}
}
from[b] = -1;
to[b] = -1;
}
void naive(int l, int r, int x){
for(int i = l; i < r; ++i){
val[i] = (val[i] == x-1) ? x : -2;
}
}
void block(int l, int r, int x){
//assert(l%B == 0 && r%B == 0);
l /= B;
r /= B;
while(l < r){
if(to[l] != -1){
to[l] = (to[l] == x-1) ? x : -2;
} else {
from[l] = x-1;
to[l] = x;
}
++l;
}
}
void exec(int l, int r, int x){
if(l/B == r/B){
sync(l/B);
naive(l,r,x);
} else {
if(l%B){
sync(l/B);
naive(l, l-l%B+B, x);
l = l-l%B+B;
}
if(r%B){
sync(r/B);
naive(r-r%B, r, x);
r = r-r%B;
}
block(l,r,x);
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
cin >> N >> K;
cin >> T;
memset(from, -1, sizeof from);
memset(to, -1, sizeof to);
while(N%B) ++N;
for(int it = 0; it < T; ++it){
int l,r,x;
cin >> l >> r >> x;
--l;
exec(l,r,x);
}
for(int i = 0; i < N/B; ++i){
sync(i);
}
cout << count(val, val+N, K) << endl;
} |
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <string>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <stdio.h>
using namespace std;
#define int long long
int MOD = 1000000007;
vector<int> sieve_of_eratosthenes(int n) {
vector<int> primes(n);
for (int i = 2; i < n; ++i)
primes[i] = i;
for (int i = 2; i*i < n; ++i)
if (primes[i])
for (int j = i*i; j < n; j += i)
primes[j] = 0;
return primes;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
vector<int> primes = sieve_of_eratosthenes(1000005);
int N;
cin >> N;
vector<int> A(N);
int res = 0;
for (int i = 0; i < N; i++) {
cin >> A[i];
}
vector<int> B;
vector<int> C;
bool f1, f2, f3;
for (int i = 0; i < N; i++) {
if (i > 0) {
f1 = (primes[A[i - 1]] != 0);
}
else {
f1 = false;
}
f2 = (primes[A[i]] != 0);
if (i < N - 1) {
f3 = (primes[A[i + 1]] != 0);
}
else {
f3 = true;
}
if (!f2 && !f3) {
cout << 0 << endl;
return 0;
}
if (!f1 && !f2) {
cout << 0 << endl;
return 0;
}
if (f2) {
if (!f1) {
B.push_back(A[i]);
C.push_back(1);
}
else if (!f3) {
B.push_back(A[i]);
C.push_back(1);
}
else {
B.push_back(A[i]);
C.push_back(0);
}
}
}
/*for (int i = 0; i < B.size(); i++) {
cerr << B[i] << " ";
}
cerr << endl;
for (int i = 0; i < C.size(); i++) {
cerr << C[i] << " ";
}
cerr << endl;*/
vector<vector<int> > dp((int)B.size() + 1, vector<int>(3, 0));
dp[0][1] = 1;
for (int i = 1; i < B.size(); i++) {
//for (int k = 0; k < 3; k++) {
if (C[i] == 0) {
if (i > 0 && B[i] > B[i - 1]) {
dp[i][1] = dp[i - 1][1];
}
if (i <= 1 || B[i] > B[i - 2]) {
dp[i][1] = (dp[i][1] + dp[i - 1][0]) % MOD;
}
dp[i][0] = (dp[i][0] + dp[i - 1][1]) % MOD;
}
else {
if (i > 0 && B[i] > B[i - 1]) {
dp[i][1] = dp[i - 1][1];
}
if (i <= 1 || B[i] > B[i - 2]) {
dp[i][1] = (dp[i][1] + dp[i - 1][0]) % MOD;
}
dp[i][0] = 0;
}
//}
}
/*for (int i = 0; i < dp.size(); i++) {
cerr << dp[i][0] << " ";
}
cerr << endl;
for (int i = 0; i < dp.size(); i++) {
cerr << dp[i][1] << " ";
}
cerr << endl;*/
cout << (dp[B.size() - 1][0] + dp[B.size() - 1][1])%MOD << endl;
}
|
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
using namespace std;
const long long int MOD = 1000000007;
long long int N, M, K, H, W, L, R;
list<int> Prime(int num) {
list<int>P;
for (int i = 5; i <= num; i += 6) {
bool flag = true;
for (auto j : P) {
if (j*j > i) {
break;
}
if (i%j == 0) {
flag = false;
break;
}
}
if (flag)P.push_back(i);
flag = true;
for (auto j : P) {
if (j*j > i + 2) {
break;
}
if ((i + 2) % j == 0) {
flag = false;
break;
}
}
if (flag)P.push_back(i + 2);
}
P.push_front(3);
P.push_front(2);
return P;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
list<int>P = Prime(1000000);
vector<bool>flag(1000001);
for (auto i : P) {
if (i > 1000000) {
break;
}
flag[i] = true;
}
cin >> N;
vector<int>v(N + 4);
v[0] = 0;
v[N + 1] = MOD;
for (int i = 1; i <= N; i++) {
cin >> v[i];
}
vector<long long int>dp(N + 4);
dp[0] = 1;
for (int i = 0; i <= N; i++) {
if (!i){
if (flag[v[1]]) {
dp[1] = 1;
}
continue;
}
if (v[i] < v[i + 1]) {
if (v[i + 1] == MOD || flag[v[i + 1]]) {
dp[i + 1] += dp[i];
dp[i + 1] %= MOD;
}
}
if (v[i] < v[i + 2]) {
if (v[i + 2] == MOD || flag[v[i + 2]]) {
dp[i + 2] += dp[i];
dp[i + 2] %= MOD;
}
}
}
cout << dp[N + 1] << endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
template<class S,class T> ostream& operator << (ostream& out,const pair<S,T>& o){ out << "(" << o.first << "," << o.second << ")"; return out; }
template<class T> ostream& operator << (ostream& out,const vector<T> V){ for(int i = 0; i < V.size(); i++){ out << V[i]; if(i!=V.size()-1) out << " ";} return out; }
template<class T> ostream& operator << (ostream& out,const vector<vector<T> > Mat){ for(int i = 0; i < Mat.size(); i++) { if(i != 0) out << endl; out << Mat[i];} return out; }
template<class S,class T> ostream& operator << (ostream& out,const map<S,T> mp){ out << "{ "; for(auto it = mp.begin(); it != mp.end(); it++){ out << it->first << ":" << it->second; if(mp.size()-1 != distance(mp.begin(),it)) out << ", "; } out << " }"; return out; }
/*
<url:https://onlinejudge.u-aizu.ac.jp/services/room.html#RitsCamp18Day3/problems/D>
問題文============================================================
えびちゃんは素因数分解マシンの不良品を持っています。
この機械は、2 以上の自然数 M を与えると O(logM) でその素因数分解を行ってくれますが、
困ったことに数字以外を表示できないバグがありました。
一般に、M の素因数分解が p1e1×p2e2×…×pKeK (ただし i<j ならば pi<pj、また各 pi は素数) の場合を考えます。
M を与えると、この機械は i=1 から順に以下のように出力を行います。全ての数字はスペース区切りで表示されます。
ei=1 ならば pi を出力する
ei>1 ならば pi ei を出力する
たとえば、22 や 2048 を与えると 2 11 と表示され、24 や 54 を与えると 2 3 3 と表示されます。
さて、えびちゃんは表示された素因数分解をメモしておいたのですが、
与えた自然数をメモしておくのを忘れていたことに気づきました。
素因数分解のメモが与えられるので、元の自然数としてありえるものがいくつあるかを求めてください。
ただし、メモが間違っていて、条件を満たす自然数が一つも存在しないこともあります。
また、その個数は非常に大きくなる場合があるので、109+7 (素数) で割ったあまりを出力してください。
=================================================================
解説=============================================================
x y z
と素数(x<y<z)が並んでいるとすると
直接zに繋がる遷移としては
y^1 z
x^y z
の二通りが考えられる
ここで dp[i] := i番目にある素数を見たときの場合の数とすると
q[i] is prime という条件のもとで
if q[i+1] is prime && q[i] < q[i+1] then
dp[i+1] += dp[i] ( x^y )
if q[i+2] is prime && q[i] < q[i+2] then
dp[i+2] += dp[i] ( x^y z )
と遷移できる
出力は dp[N-1] + dp[N-2] ( y^1 z のパターン と x^y z のパターン)
================================================================
*/
#define MAX_N 1000005
bool is_prime[MAX_N];
const ll MOD = 1e9+7;
bool IsPrime(int num)
{
if (num < 2) return false;
else if (num == 2) return true;
else if (num % 2 == 0) return false; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2){
if (num % i == 0){
return false;
}
}
return true;
}
void init(){
for(int i = 1; i < MAX_N;i++){
is_prime[i] = IsPrime(i);
}
}
ll solve(){
ll N; cin >> N;
vector<ll> q(N);
for(auto& in:q)cin >> in;
if(!is_prime[q[0]]) return 0;
if(N == 1) return 1;
int cnt = 0;
for(int i = 0; i < N;i++){
if(!is_prime[q[i]]) cnt++;
else cnt = 0;
if(cnt == 2) return 0;
}
vector<ll> dp(N+1,0);
dp[0] = 1;
for(int i = 0; i < N;i++){
if(is_prime[q[i]]){
if( i+1 < N && is_prime[q[i+1]] && (q[i] < q[i+1])){
(dp[i+1] += dp[i])%=MOD;
}
if( i+2 < N && is_prime[q[i+2]] && (q[i] < q[i+2])){
(dp[i+2] += dp[i])%=MOD;
}
}
}
return (dp[N-1]+dp[N-2])%MOD;
}
int main(void) {
cin.tie(0); ios::sync_with_stdio(false);
init();
cout << solve() << endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
template<class S,class T> ostream& operator << (ostream& out,const pair<S,T>& o){ out << "(" << o.first << "," << o.second << ")"; return out; }
template<class T> ostream& operator << (ostream& out,const vector<T> V){ for(int i = 0; i < V.size(); i++){ out << V[i]; if(i!=V.size()-1) out << " ";} return out; }
template<class T> ostream& operator << (ostream& out,const vector<vector<T> > Mat){ for(int i = 0; i < Mat.size(); i++) { if(i != 0) out << endl; out << Mat[i];} return out; }
template<class S,class T> ostream& operator << (ostream& out,const map<S,T> mp){ out << "{ "; for(auto it = mp.begin(); it != mp.end(); it++){ out << it->first << ":" << it->second; if(mp.size()-1 != distance(mp.begin(),it)) out << ", "; } out << " }"; return out; }
/*
<url:https://onlinejudge.u-aizu.ac.jp/services/room.html#RitsCamp18Day3/problems/D>
問題文============================================================
えびちゃんは素因数分解マシンの不良品を持っています。
この機械は、2 以上の自然数 M を与えると O(logM) でその素因数分解を行ってくれますが、
困ったことに数字以外を表示できないバグがありました。
一般に、M の素因数分解が p1e1×p2e2×…×pKeK (ただし i<j ならば pi<pj、また各 pi は素数) の場合を考えます。
M を与えると、この機械は i=1 から順に以下のように出力を行います。全ての数字はスペース区切りで表示されます。
ei=1 ならば pi を出力する
ei>1 ならば pi ei を出力する
たとえば、22 や 2048 を与えると 2 11 と表示され、24 や 54 を与えると 2 3 3 と表示されます。
さて、えびちゃんは表示された素因数分解をメモしておいたのですが、
与えた自然数をメモしておくのを忘れていたことに気づきました。
素因数分解のメモが与えられるので、元の自然数としてありえるものがいくつあるかを求めてください。
ただし、メモが間違っていて、条件を満たす自然数が一つも存在しないこともあります。
また、その個数は非常に大きくなる場合があるので、109+7 (素数) で割ったあまりを出力してください。
=================================================================
解説=============================================================
================================================================
*/
#define MAX_N 1000005
bool is_prime[MAX_N];
const ll MOD = 1e9+7;
bool IsPrime(int num)
{
if (num < 2) return false;
else if (num == 2) return true;
else if (num % 2 == 0) return false; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2){
if (num % i == 0){
return false;
}
}
return true;
}
void init(){
for(int i = 1; i < MAX_N;i++){
is_prime[i] = IsPrime(i);
}
}
ll solve(){
ll N; cin >> N;
vector<ll> q(N);
for(auto& in:q)cin >> in;
if(!is_prime[q[0]]) return 0;
int cnt = 0;
for(int i = 0; i < N;i++){
if(!is_prime[q[i]]) cnt++;
else cnt = 0;
if(cnt == 2) return 0;
}
vector<ll> dp(N+1,0);
dp[0] = 1;
for(int i = 0; i < N;i++){
if(is_prime[q[i]]){
if(i+1 == N || is_prime[q[i+1]] && (q[i] < q[i+1])){
(dp[i+1] += dp[i])%=MOD;
}
if(i+2 == N || is_prime[q[i+2]] && (q[i] < q[i+2])){
(dp[i+2] += dp[i])%=MOD;
}
}
}
return dp[N]%MOD;
}
int main(void) {
cin.tie(0); ios::sync_with_stdio(false);
init();
cout << solve() << endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
template<class S,class T> ostream& operator << (ostream& out,const pair<S,T>& o){ out << "(" << o.first << "," << o.second << ")"; return out; }
template<class T> ostream& operator << (ostream& out,const vector<T> V){ for(int i = 0; i < V.size(); i++){ out << V[i]; if(i!=V.size()-1) out << " ";} return out; }
template<class T> ostream& operator << (ostream& out,const vector<vector<T> > Mat){ for(int i = 0; i < Mat.size(); i++) { if(i != 0) out << endl; out << Mat[i];} return out; }
template<class S,class T> ostream& operator << (ostream& out,const map<S,T> mp){ out << "{ "; for(auto it = mp.begin(); it != mp.end(); it++){ out << it->first << ":" << it->second; if(mp.size()-1 != distance(mp.begin(),it)) out << ", "; } out << " }"; return out; }
/*
<url:https://onlinejudge.u-aizu.ac.jp/services/room.html#RitsCamp18Day3/problems/D>
問題文============================================================
えびちゃんは素因数分解マシンの不良品を持っています。
この機械は、2 以上の自然数 M を与えると O(logM) でその素因数分解を行ってくれますが、
困ったことに数字以外を表示できないバグがありました。
一般に、M の素因数分解が p1e1×p2e2×…×pKeK (ただし i<j ならば pi<pj、また各 pi は素数) の場合を考えます。
M を与えると、この機械は i=1 から順に以下のように出力を行います。全ての数字はスペース区切りで表示されます。
ei=1 ならば pi を出力する
ei>1 ならば pi ei を出力する
たとえば、22 や 2048 を与えると 2 11 と表示され、24 や 54 を与えると 2 3 3 と表示されます。
さて、えびちゃんは表示された素因数分解をメモしておいたのですが、
与えた自然数をメモしておくのを忘れていたことに気づきました。
素因数分解のメモが与えられるので、元の自然数としてありえるものがいくつあるかを求めてください。
ただし、メモが間違っていて、条件を満たす自然数が一つも存在しないこともあります。
また、その個数は非常に大きくなる場合があるので、109+7 (素数) で割ったあまりを出力してください。
=================================================================
解説=============================================================
================================================================
*/
#define MAX_N 1000005
bool is_prime[MAX_N];
const ll MOD = 1e9+7;
bool IsPrime(int num)
{
if (num < 2) return false;
else if (num == 2) return true;
else if (num % 2 == 0) return false; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2){
if (num % i == 0){
return false;
}
}
return true;
}
void init(){
for(int i = 1; i < MAX_N;i++){
is_prime[i] = IsPrime(i);
}
}
ll solve(){
ll N; cin >> N;
vector<ll> q(N);
for(auto& in:q)cin >> in;
if(!is_prime[q[0]]) return 0;
if(N == 1) return 1;
int cnt = 0;
for(int i = 0; i < N;i++){
if(!is_prime[q[i]]) cnt++;
else cnt = 0;
if(cnt == 2) return 0;
}
vector<ll> dp(N+1,0);
dp[0] = 1;
for(int i = 0; i < N;i++){
if(is_prime[q[i]]){
if( i+1 < N && is_prime[q[i+1]] && (q[i] < q[i+1])){
(dp[i+1] += dp[i])%=MOD;
}
if( i+2 < N && is_prime[q[i+2]] && (q[i] < q[i+2])){
(dp[i+2] += dp[i])%=MOD;
}
}
}
return (dp[N-1]+dp[N-2])%MOD;
}
int main(void) {
cin.tie(0); ios::sync_with_stdio(false);
init();
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define int long long
#define range(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, a) range(i, 0, a)
using namespace std;
const int INF = sizeof(int) == sizeof(long long) ? 1e18 : 1e9;
const int MOD = 1000000007;
const long double EPS = 1e-8;
int n;
int q[100010];
int dp[100010][2];
bool b[100010];
signed main() {
cin >> n;
rep (i, n) {
cin >> q[i];
b[i] = true;
for (int j = 2; j * j <= q[i]; j++) b[i] = b[i] && (q[i] % j != 0 || q[i] == j);
}
rep (i, n) {
// i 番目を q とする
if (i == 0) {
dp[i][0] = b[i];
continue;
}
if (b[i]) {
if (q[i - 1] < q[i]) dp[i][0] = (dp[i][0] + dp[i - 1][0]) % MOD;
if (i > 1 && q[i - 2] < q[i]) dp[i][0] = (dp[i][0] + dp[i - 1][1]) % MOD;
}
// i 番目を e とする
dp[i][1] = (dp[i][1] + dp[i - 1][0]) % MOD;
}
cout << (dp[n - 1][0] + dp[n - 1][1]) % MOD << endl;
//rep (i, n + 1) cout << dp[i][0] << " " << dp[i][1] << endl;
return 0;
}
|
#include <string>
#include <vector>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <map>
#include <set>
#define REP(i,n) for(int i=0;i<n;i++)
#define LOOP(i,x,n) for(int i=x;i<n;i++)
#define ALL(v) (v).begin(),(v).end()
#define int long long
using namespace std;
const int MOD=1e9+7;
const int INF=1e10;
const int MAX_N = 1123456;
bool isPrime[MAX_N];
void e(){
REP(i,MAX_N){
isPrime[i]=true;
}
isPrime[0]=isPrime[1]=false;
REP(i,MAX_N){
if(isPrime[i]){
for(int j = i+i;j<MAX_N;j+=i){
isPrime[j]=false;
}
}
}
}
bool Is_Prime(int n){
return isPrime[n];
}
int dp[100005];
signed main(){
e();
int n;
cin>>n;
vector<int> q(n);
REP(i,n)cin>>q[i];
if(Is_Prime(q[0]))dp[0]=1;
REP(i,n){
//cout<<dp[i]<<endl;
if(i+2<n&&q[i]<q[i+2]&&Is_Prime(q[i+2])){
dp[i+2]+=dp[i];
dp[i+2]%=MOD;
}
if(i+1<n&&q[i]<q[i+1]&&Is_Prime(q[i+1])){
dp[i+1]+=dp[i];
dp[i+1]%=MOD;
}
}
cout<<(dp[n-1]+dp[n-2])%MOD<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int M = 1000000007;
int main() {
int isp[1000010] = {};
for (int i = 2; i < 1000010; i++) isp[i] = 1;
for (int i = 2; i * i < 1000010; i++) if (isp[i]) for (int j = i * i; j < 1000010; j += i) isp[j] = 0;
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<vector<long long>> dp(n, vector<long long>(2));
dp[0][0] = isp[a[0]];
for (int i = 1; i < n; ++i) {
if (a[i] > a[i - 1] && isp[a[i]]) {
dp[i][0] = (dp[i][0] + dp[i - 1][0]) % M;
}
if (i > 1 && a[i] > a[i - 2] && isp[a[i]]) {
dp[i][0] = (dp[i][0] + dp[i - 2][0]) % M;
}
dp[i][1] = dp[i - 1][0];
}
cout << (dp[n - 1][0] + dp[n - 1][1]) % M << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define DBG cerr << '!' << endl;
#define REP(i,n) for(ll (i) = (0);(i) < (n);++i)
#define rep(i,s,g) for(ll (i) = (s);(i) < (g);++i)
#define rrep(i,s,g) for(ll (i) = (s);i >= (g);--(i))
#define PB push_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v,n) {for(int W = 0;W < (n);W++)cerr << v[W] << ' ';cerr << endl << endl;}
#define SHOW2d(v,i,j) {for(int aaa = 0;aaa < i;aaa++){for(int bbb = 0;bbb < j;bbb++)cerr << v[aaa][bbb] << ' ';cerr << endl;}cerr << endl;}
#define ALL(v) v.begin(),v.end()
#define Decimal fixed<<setprecision(10)
#define INF 1000000000
#define MOD 1000000007
typedef long long ll;
typedef pair<ll,ll> P;
bool isp[1111111];
ll dp[100010][2];
void era(){
isp[0] = isp[1] = true;
for(int i = 2 ; i < 1000001;i++){
if(!isp[i]){
for(int j = 2*i;j < 1000001;j += i){
isp[j] = true;
}
}
}
}
int main()
{
era();
//SHOW1d(isp,100);
int n;cin >> n;
vector<int> v(n);
REP(i,n){
cin >> v[i];
}
dp[0][0] = 1;
for(int i = 0;i < n;i++){
for(int j = 0;j < 2;j++){
if(dp[i][j]){
if(j == 0){
if((i == 0 && !isp[v[i]]) ||(i > 1 && !isp[v[i]] && v[i] > v[i-2])){
dp[i+1][1] = (dp[i+1][1] + dp[i][0]) % MOD;
}
}
else{
if(!isp[v[i]] && v[i] > v[i-1]){
dp[i+1][1] = (dp[i+1][1] + dp[i][j]) %MOD;
}
dp[i+1][0] = (dp[i+1][0] + dp[i][j]) % MOD;
}
}
}
}
//REP(i,n+1)cout << dp[i][0] << ' ';cout << endl;
//REP(i,n+1)cout << dp[i][1] << ' ';cout << endl;
cout << (dp[n][0] + dp[n][1]) % MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, a, n) for(ll i = ((ll) a); i < ((ll) n); i++)
using namespace std;
typedef long long ll;
const ll MOD = 1000000007LL;
int main(void) {
ll N;
cin >> N;
vector<ll> P(N);
REP(i, 0, N) cin >> P[i];
const ll PMAX = 1000001;
vector<bool> prime(PMAX, true);
prime[1] = false;
REP(i, 2, PMAX) if(prime[i]) for(ll j = i + i; j < PMAX; j += i) prime[j] = false;
vector<ll> dp1(N, 0), dp2(N, 0);
REP(i, 0, N) {
if(i == 0) {
if(prime[P[i]]) (dp1[i] += 1) %= MOD;
} else if(i == 1) {
if(prime[P[i]] && P[i - 1] < P[i]) (dp1[i] += dp1[i - 1]) %= MOD;
if(prime[P[i - 1]]) (dp2[i] += 1) %= MOD;
} else if(i == 2) {
if(prime[P[i]] && P[i - 1] < P[i]) (dp1[i] += dp1[i - 1]) %= MOD;
if(prime[P[i]] && P[i - 2] < P[i]) (dp1[i] += dp2[i - 1]) %= MOD;
if(prime[P[i - 1]] && P[i - 2] < P[i - 1]) (dp2[i] += dp1[i - 2]) %= MOD;
} else {
if(prime[P[i]] && P[i - 1] < P[i]) (dp1[i] += dp1[i - 1]) %= MOD;
if(prime[P[i]] && P[i - 2] < P[i]) (dp1[i] += dp2[i - 1]) %= MOD;
if(prime[P[i - 1]] && P[i - 2] < P[i - 1]) (dp2[i] += dp1[i - 2]) %= MOD;
if(prime[P[i - 1]] && P[i - 3] < P[i - 1]) (dp2[i] += dp2[i - 2]) %= MOD;
}
}
cout << (dp1[N - 1] + dp2[N - 1]) % MOD << endl;
}
|
#include <bits/stdc++.h>
#define range(i, a, b) for(auto i = a; i < b; i++)
#define rep(i, a) range(i, 0, a)
using namespace std;
const int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
const int MOD = 1000000007;
const long double EPS = 1e-8;
int n;
long long q[1000010];
bool b[1000010];
long long memo[100010][2];
long long solve(int i = 0, int prevIsE = true) {
int pear = 1, berry = 1;
bool flaga = false, flagb = false;
if (i == n) {
return 1;
}
if (memo[i][prevIsE] != -1) {
return memo[i][prevIsE];
}
// cout << i << " " << b[q[i]] << " " << q[i - 1 - prevIsE] << " " << q[i] << endl;
if (i != 0 && b[q[i]] && q[i - 1 - prevIsE] < q[i]
|| i == 0 && b[q[i]]) {
// if (sosu[q[i]] && prevSosu < q[i]) {
// cout << i << " is q" << endl;
pear = pear * solve(i + 1, false) % MOD;
flaga = true;
}
if (!prevIsE) {
// cout << i << " is e" << endl;
berry = berry * solve(i + 1, true) % MOD;
flagb = true;
}
pear *= flaga;
berry *= flagb;
// cout << i << " " << pear + berry << endl;
return memo[i][prevIsE] = (pear + berry) % MOD;
}
signed main() {
cin >> n;
rep (i, n) {
cin >> q[i];
b[q[i]] = true;
for (int j = 2; j * j <= q[i]; j++) b[q[i]] = b[q[i]] && (q[i] % j != 0);
}
rep (i, 100010) rep (j, 2) memo[i][j] = -1;
cout << solve() << endl;
return 0;
}
|
// g++ -std=c++11 a.cpp
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<random>
#include<cstring>
#include<queue>
#include<stack>
#include<bitset>
#include<cstdio>
#include<sstream>
#include<iomanip>
#include<assert.h>
#include<typeinfo>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
using namespace std;
//kaewasuretyuui
typedef long long ll;
//#define int ll
typedef int Def;
typedef pair<Def,Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def,pii> pip;
typedef vector<pip>vip;
#define mt make_tuple
typedef tuple<int,int,int> tp;
typedef vector<tp> vt;
template<typename A,typename B>bool cmin(A &a,const B &b){return a>b?(a=b,true):false;}
template<typename A,typename B>bool cmax(A &a,const B &b){return a<b?(a=b,true):false;}
//template<class C>constexpr int size(const C &c){return (int)c.size();}
//template<class T,size_t N> constexpr int size(const T (&xs)[N])noexcept{return (int)N;}
const double PI=acos(-1);
const double EPS=1e-7;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9+10;
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
#define MAX 1000100
int MOD=1000000007;
int sosu[MAX]={1,1,0};
vi sos;
void init(){
for(int i=2;i*i<=MAX;i++)if(!sosu[i])
for(int j=i*2;j<MAX;j+=i)sosu[j]=true;
rep(i,MAX)if(sosu[i]==0)sos.pb(i);
}
int main(){
init();
int n;
cin>>n;
vi in(n+1,inf);
rep(i,n)cin>>in[i];
if(n==1){
cout<<!sosu[in[0]]<<endl;
return 0;
}
vi dp(n+1);
dp[n]=1;
if(!sosu[in[n-1]])dp[n-1]=1;
for(int i=n-2;i>=0;i--)if(!sosu[in[i]]){
if(in[i]<in[i+1])(dp[i]+=dp[i+1])%=MOD;
if(in[i]<in[i+2])(dp[i]+=dp[i+2])%=MOD;
}
cout<<dp[0]<<endl;
}
|
#include<iostream>
#include<utility>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
constexpr int Q_MAX = 1000006;
bool is_prime[Q_MAX];
void init() {
rep(i, Q_MAX) is_prime[i] = true;
is_prime[0] = is_prime[1] = false;
rep(i, Q_MAX) if (i >= 2) {
if (is_prime[i]) {
for (int j = i * 2; j < Q_MAX; j += i) is_prime[j] = false;
}
}
}
int n,a[1<<17];
long long dp[1<<17];
long long mod=1e9+7;
int main()
{
cin>>n;
for(int i=0;i<n;i++)
{
cin>>a[i];
}
init();
if(n==1)
{
cout<<is_prime[a[0]]<<endl;
return 0;
}
dp[0]=is_prime[a[0]];
for(int i=0;i<n;i++)
{
if(!is_prime[a[i]])continue;
if(is_prime[a[i+2]]&&a[i+2]>a[i])dp[i+2]=(dp[i+2]+dp[i])%mod;
if(is_prime[a[i+1]]&&a[i+1]>a[i])dp[i+1]=(dp[i+1]+dp[i])%mod;
}
cout<<((dp[n-1]+dp[n-2])%mod)<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define resz(v, ...) (v).clear(), (v).resize(__VA_ARGS__)
#define reps(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
template<class T1, class T2> void chmin(T1 &a, T2 b){if(a>b)a=b;}
template<class T1, class T2> void chmax(T1 &a, T2 b){if(a<b)a=b;}
using Pi = pair<int, int>;
using Tapris = tuple<int, int, int>;
using vint = vector<int>;
const int inf = 1LL << 55;
const int mod = 1e9 + 7;
void enum_prime(int N, vector<bool>& is_p)
{
is_p.resize(N+1, true);
is_p[0] = is_p[1] = false;
for(int i = 2; i*i <= N; i++) {
if(!is_p[i]) continue;
for(int j = i+i; j <= N; j+=i) is_p[j] = false;
}
}
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
const int MAX_Q = 1000000;
vector<bool> is_p;
enum_prime(MAX_Q, is_p);
int n;
cin >> n;
vint q(n);
rep(i, n) cin >> q[i];
if(!is_p[q[0]]) {
cout << 0 << endl;
return 0;
}
vector<vint> dp(2, vint(n+1, 0));
dp[0][0] = 1;
dp[1][0] = 0;
reps(i, 1, n) {
if(is_p[q[i]]) {
if(q[i-1] < q[i]) (dp[0][i] += dp[0][i-1]) %= mod;
if(i>1&&q[i-2] < q[i]) (dp[0][i] += dp[1][i-1]) %= mod;
}
(dp[1][i] += dp[0][i-1]) %= mod;
}
cout << (dp[0][n-1]+dp[1][n-1])%mod << endl;
return 0;
}
|
#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_popcount
#define INF 1e16
#define mod 1000000007
ll n;
ll a[101010];
bool is_prime[1000001];
ll dp[100001][2];
int main(){
repl(i,2,1000001)is_prime[i]=true;
for(ll i=2;i<=1000000;i++){
if(!is_prime[i])continue;
for(ll j=i*2;j<=1000000;j+=i){
is_prime[j]=false;
}
}
cin>>n;
rep(i,n)cin>>a[i];
if(!is_prime[a[0]]){
cout<<0<<endl;
return 0;
}
dp[1][0]=1;
repl(i,1,n){
rep(j,2){
if(j){
if(is_prime[a[i]]&&a[i-2]<a[i]){
(dp[i+1][0]+=dp[i][j])%=mod;
}
}else{
if(is_prime[a[i]]&&a[i-1]<a[i]){
(dp[i+1][0]+=dp[i][j])%=mod;
(dp[i+1][1]+=dp[i][j])%=mod;
}else{
(dp[i+1][1]+=dp[i][j])%=mod;
}
}
}
}
cout<<(dp[n][0]+dp[n][1])%mod<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
const int N = 1001000;
bool prime[N];
const ll mod = 1e9+7;
int main(){
fill(prime,prime+N,true);
prime[0] = prime[1] = false;
for(int i=2; i<N; ++i){
if(prime[i]) for(int j=2*i; j<N; j+=i) prime[j] = false;
}
int n;
cin >>n;
vector<int> q(n);
rep(i,n) cin >>q[i];
q.pb(1000999);
vector<ll> dp(n+1);
dp[0] = 1;
rep(i,n)if(prime[q[i]]){
// 1個
if(i+1<=n && prime[q[i+1]] && q[i]<q[i+1]) (dp[i+1] += dp[i]) %= mod;
// 2個
if(i+2<=n && prime[q[i+2]] && q[i]<q[i+2]) (dp[i+2] += dp[i]) %= mod;
}
cout << dp[n] << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long int lli;
const int MAX = 1e6+1;
const lli mod = 1e9+7;
int main(){
vector<bool> prime(MAX, true);
prime[0] = prime[1] = false;
for(int i=2; i*i<MAX; i++){
if(prime[i]){
for(int j=i*2; j<MAX; j+=i){
prime[j] = false;
}
}
}
int n;
cin >> n;
vector<int> q(n+1, 0);
for(int i=1; i<=n; i++){
cin >> q[i];
}
vector<vector<lli> > dp(n+1, vector<lli>(2, 0));
dp[0][0] = 1;
for(int i=0; i<n; i++){
if(!prime[q[i+1]]) continue;
for(int j=0; j<2; j++){
if(dp[i][j] != 0){
if(q[i-j] < q[i+1]){
dp[i+1][0] = (dp[i+1][0] +dp[i][j])%mod;
if(i+2 <= n){
dp[i+2][1] = (dp[i+2][1] +dp[i][j])%mod;
}
}
}
}
}
cout << (dp[n][0] +dp[n][1])%mod << endl;
return 0;
}
|
#include <iostream>
using namespace std;
typedef long long ll;
#define M 1000000007
int n,q[100005];
ll dp[2][100005];
bool s[1000005];
int main(void){
cin>>n;
for(int i=0;i<n;i++)cin>>q[i];
for(int i=2;i<=1000;i++){
if(!s[i]){
for(int j=i*2;j<=1000000;j+=i)s[j]=true;
}
}
if(!s[q[0]])dp[1][1]=1;
for(int i=1;i<n;i++){
dp[0][i+1]=dp[1][i];
if(!s[q[i]]){
if(i>0&&q[i-1]<q[i])dp[1][i+1]=dp[1][i];
if(i>1&&q[i-2]<q[i])dp[1][i+1]=(dp[1][i+1]+dp[0][i])%M;
}
}
cout<<(dp[0][n]+dp[1][n])%M<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
#define ALL(a) begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FF first
#define SS second
#define DUMP(x) cout<<#x<<":"<<(x)<<endl
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
return is >> p.FF >> p.SS;
}
template<class T>
istream& operator>>(istream& is, vector<T>& xs){
for(auto& x: xs)
is >> x;
return is;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
return os << p.FF << " " << p.SS;
}
template<class T>
ostream& operator<<(ostream& os, const vector<T>& xs){
for(unsigned int i=0;i<xs.size();++i)
os << (i?" ":"") << xs[i];
return os;
}
template<class T>
void maxi(T& x, T y){
if(x < y) x = y;
}
template<class T>
void mini(T& x, T y){
if(x > y) x = y;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const LL MOD = 1e9+7;
const int MAX = 1e6+10;
bool isp[MAX];
LL dp[MAX];
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
int N;
cin >> N;
VI xs(N);
cin >> xs;
fill(isp, isp+MAX, true);
isp[0] = isp[1] = false;
for(int i=2;i<MAX;++i)
if(isp[i])
for(int j=i+i;j<MAX;j+=i)
isp[j] = false;
if(!isp[xs[0]]){
cout << 0 << endl;
return 0;
}
if(N == 1){
cout << 1 << endl;
return 0;
}
dp[0] = 1;
for(int i=1;i<N;++i){
if(isp[xs[i]]){
if(isp[xs[i-1]] && xs[i-1] < xs[i])
(dp[i] += dp[i-1]) %= MOD;
if(i>=2 && isp[xs[i-2]] && xs[i-2] < xs[i])
(dp[i] += dp[i-2]) %= MOD;
}
}
LL ans = 0;
if(isp[xs[N-1]]) ans += dp[N-1];
if(isp[xs[N-2]]) ans += dp[N-2];
cout << ans%MOD << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define int long long
using namespace std;
bool prime[1000009];
void era(){
prime[0]=1;
prime[1]=1;
for(int i=2;i<1000009;i++){
if(!prime[i]){
for(int j=i+i;j<1000009;j+=i) prime[j]=1;
}
}
}
int dp[100009][2];
signed main(){
era();
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)cin>>a[i];
if(!prime[a[0]]){
dp[0][0]=1;
dp[0][1]=1;
}
for(int i=0;i<n;i++){
// 1
if( i+1<n && a[i]<a[i+1] &&!prime[a[i+1]] )dp[i+1][0] += dp[i][0];
if( i+2<n && a[i]<a[i+1] &&!prime[a[i+1]] )dp[i+1][1] += dp[i][0];
// 2
if( i+2<n && a[i]<a[i+2] &&!prime[a[i+2]] )dp[i+2][0] += dp[i][1];
if( i+3<n && a[i]<a[i+2] &&!prime[a[i+2]] )dp[i+2][1] += dp[i][1];
dp[i+1][0]%=1000000007;
dp[i+1][1]%=1000000007;
dp[i+2][0]%=1000000007;
dp[i+2][1]%=1000000007;
}
cout<<(dp[n-1][0]+dp[n-2][1])%1000000007<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
bool isprime(int num){
if(num<2)return false;
else if(num==2)return true;
else if(num % 2 == 0)return false;
int sqrtnum=sqrt(num);
for(int i=3;i<=sqrtnum;i+=2){
if(num%i==0){
return false;
}
}
return true;
}
int main(){
int n;
cin>>n;
ll q[100001]={0};
for(int i=0;i<n;++i){
cin>>q[i];
}
ll dp[100001]={0};
if(isprime(q[0]))dp[0]=1;
if(isprime(q[1]))if(dp[0]==1 && q[0]<q[1])dp[1]=1;
for(int i=2;i<n;++i){
if(!isprime(q[i]))continue;
if(q[i-1]<q[i])dp[i]+=dp[i-1];
if(q[i-2]<q[i])dp[i]+=dp[i-2];
dp[i]%=1000000007;
}
if(n==1)cout<<dp[0]<<endl;
else cout<<(dp[n-2]+dp[n-1])%1000000007<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector< bool > get_prime(int n) {
vector< bool > prime(n + 1, true);
if(n >= 0) prime[0] = false;
if(n >= 1) prime[1] = false;
for(int i = 2; i * i <= n; i++) {
if(prime[i]) {
for(int j = i + i; j <= n; j += i) prime[j] = false;
}
}
return (prime);
}
auto table = get_prime(1000000);
const int mod = 1e9 + 7;
int N, Q[100000];
int dp[100000];
int rec(int idx) {
if(idx == N) return 1;
if(~dp[idx]) return dp[idx];
if(!table[Q[idx]]) return dp[idx] = 0;
int ret = 0;
if(idx + 1 == N || Q[idx] < Q[idx + 1]) {
(ret += rec(idx + 1)) %= mod;
}
if(idx + 1 < N) {
if(Q[idx + 1] > 1) {
if(idx + 2 == N || Q[idx] < Q[idx + 2]) {
(ret += rec(idx + 2)) %= mod;
}
}
}
return dp[idx] = ret;
}
int main() {
cin >> N;
for(int i = 0; i < N; i++) {
cin >> Q[i];
}
memset(dp, -1, sizeof(dp));
cout << rec(0) << endl;
}
|
// need
#include <iostream>
#include <algorithm>
// data structure
#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
//#include <complex>
//#include <deque>
#include <valarray>
// stream
//#include <istream>
//#include <sstream>
//#include <ostream>
#include <fstream>
// etc
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <chrono>
#include <random>
#include <numeric>
// input
#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);
#define VAR(type, ...)type __VA_ARGS__;MACRO_VAR_Scan(__VA_ARGS__);
template<typename T> void MACRO_VAR_Scan(T& t) { std::cin >> t; }
template<typename First, typename...Rest>void MACRO_VAR_Scan(First& first, Rest&...rest) { std::cin >> first; MACRO_VAR_Scan(rest...); }
#define VEC_ROW(type, n, ...)std::vector<type> __VA_ARGS__;MACRO_VEC_ROW_Init(n, __VA_ARGS__); for(int i=0; i<n; ++i){MACRO_VEC_ROW_Scan(i, __VA_ARGS__);}
template<typename T> void MACRO_VEC_ROW_Init(int n, T& t) { t.resize(n); }
template<typename First, typename...Rest>void MACRO_VEC_ROW_Init(int n, First& first, Rest&...rest) { first.resize(n); MACRO_VEC_ROW_Init(n, rest...); }
template<typename T> void MACRO_VEC_ROW_Scan(int p, T& t) { std::cin >> t[p]; }
template<typename First, typename...Rest>void MACRO_VEC_ROW_Scan(int p, First& first, Rest&...rest) { std::cin >> first[p]; MACRO_VEC_ROW_Scan(p, rest...); }
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define MAT(type, c, m, n) std::vector<std::vector<type>> c(m, std::vector<type>(n));for(auto& r:c)for(auto& i:r)std::cin>>i;
// output
#define OUT(d) std::cout<<(d);
#define FOUT(n, d) std::cout<<std::fixed<<std::setprecision(n)<<(d);
#define SOUT(n, c, d) std::cout<<std::setw(n)<<std::setfill(c)<<(d);
#define SP std::cout<<" ";
#define TAB std::cout<<"\t";
#define BR std::cout<<"\n";
#define SPBR(i, n) std::cout<<(i + 1 == n ? '\n' : ' ');
#define ENDL std::cout<<std::endl;
#define FLUSH std::cout<<std::flush;
#define SHOW(d) {std::cerr << #d << "\t:" << (d) << "\n";}
#define SHOWVECTOR(v) {std::cerr << #v << "\t:";for(const auto& xxx : v){std::cerr << xxx << " ";}std::cerr << "\n";}
#define SHOWVECTOR2(v) {std::cerr << #v << "\t:\n";for(const auto& xxx : v){for(const auto& yyy : xxx){std::cerr << yyy << " ";}std::cerr << "\n";}}
#define SHOWQUEUE(a) {auto tmp(a);std::cerr << #a << "\t:";while(!tmp.empty()){std::cerr << tmp.front() << " ";tmp.pop();}std::cerr << "\n";}
// utility
#define ALL(a) (a).begin(),(a).end()
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define RFOR(i, a, b) for(int i=(b)-1;i>=(a);--i)
#define REP(i, n) for(int i=0;i<int(n);++i)
#define RREP(i, n) for(int i=int(n)-1;i>=0;--i)
#define FORLL(i, a, b) for(ll i=ll(a);i<ll(b);++i)
#define RFORLL(i, a, b) for(ll i=ll(b)-1;i>=ll(a);--i)
#define REPLL(i, n) for(ll i=0;i<ll(n);++i)
#define RREPLL(i, n) for(ll i=ll(n)-1;i>=0;--i)
#define IN(a, x, b) (a<=x && x<b)
template<typename T> inline T CHMAX(T& a, const T b) { return a = (a < b) ? b : a; }
template<typename T> inline T CHMIN(T& a, const T b) { return a = (a > b) ? b : a; }
#define EXCEPTION(msg) throw std::string("Exception : " msg " [ in ") + __func__ + " : " + std::to_string(__LINE__) + " lines ]"
#define TRY(cond, msg) try {if (cond) EXCEPTION(msg);}catch (std::string s) {std::cerr << s << std::endl;}
void CHECKTIME(std::function<void()> f) { auto start = std::chrono::system_clock::now(); f(); auto end = std::chrono::system_clock::now(); auto res = std::chrono::duration_cast<std::chrono::nanoseconds>((end - start)).count(); std::cerr << "[Time:" << res << "ns (" << res / (1.0e9) << "s)]\n"; }
// test
template<class T> std::vector<std::vector<T>> VV(int n, int m, T init = T()) {
return std::vector<std::vector<T>>(n, std::vector<T>(m, init));
}
template<typename S, typename T>
std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")"; return os;
}
// type/const
//#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = 1 << 30; // 1.07x10^ 9
constexpr int INFINT_LIM = (1LL << 31) - 1; // 2.15x10^ 9
constexpr ll INFLL = 1LL << 60; // 1.15x10^18
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62); // 9.22x10^18
constexpr double EPS = 1e-9;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
template<class T, size_t N> void FILL(T(&a)[N], const T& val) { for (auto& x : a) x = val; }
template<class ARY, size_t N, size_t M, class T> void FILL(ARY(&a)[N][M], const T& val) { for (auto& b : a) FILL(b, val); }
template<class T> void FILL(std::vector<T>& a, const T& val) { for (auto& x : a) x = val; }
template<class ARY, class T> void FILL(std::vector<std::vector<ARY>>& a, const T& val) { for (auto& b : a) FILL(b, val); }
// ------------>8------------------------------------->8------------
std::vector<int> Eratosthenes(int n) {
std::vector<int> num(n + 1, 0);
num[0] = num[1] = -1;
int cnt = 0;
for (int i = 2; i*i < n; ++i) {
if (num[i] == 0) {
for (int j = 2; i*j <= n; ++j) {
num[i*j] = -1;
}
num[i] = cnt++;
}
}
return num;
}
int dp[2][2][78500];
// dp[i][j][k] = i%2番目までみてi番目を(j:p->0/e->1)として出てきた
// 最大の素数がk番目の素数の場合の数
int solve(int n, std::vector<int> q) {
auto p(Eratosthenes(1000001));
if (p[q[0]] == -1) return 0;
dp[1][0][p[q[0]]] = 1;
int mi = p[q[0]], ma = p[q[0]];
FOR(i, 1, n) {
int nmi = INFINT, nma = -INFINT;
REP(j, 2) {
if (p[q[i]] == -1 && j == 1) continue;
FOR(k, mi, ma + 1) {
if (dp[i & 1][j][k] == 0) continue;
if (p[q[i]] == -1) { // 素数じゃない
(dp[1 - i % 2][1][k] += dp[i % 2][j][k]) %= MOD;
CHMIN(nmi, k);
CHMAX(nma, k);
}
else { // 素数
if (k >= p[q[i]]) {
if (j == 0) {
(dp[1 - i % 2][1][k] += dp[i % 2][j][k]) %= MOD;
CHMIN(nmi, k);
CHMAX(nma, k);
}
}
else {
if (j == 0) {
(dp[1 - i % 2][1][k] += dp[i % 2][j][k]) %= MOD;
CHMIN(nmi, k);
CHMAX(nma, k);
}
(dp[1 - i % 2][0][p[q[i]]] += dp[i % 2][j][k]) %= MOD;
CHMIN(nmi, p[q[i]]);
CHMAX(nma, p[q[i]]);
}
}
}
}
if (nmi > nma) return 0;
mi = nmi;
ma = nma;
FILL(dp[i % 2], 0);
}
int ans = 0;
REP(j, 2) REP(k, ma + 1) {
(ans += dp[n % 2][j][k]) %= MOD;
}
return ans;
};
int solve2(int n, std::vector<int> q) {
auto p(Eratosthenes(2000001));
std::map<PAIR, ll> map;
std::function<ll(int, int)> rec = [&](int i, int ma) {
if (i == n) return 1LL;
if (i > n) return 0LL;
if (p[q[i]] == -1) return 0LL;
if (ma >= q[i]) return 0LL;
if (map.count(PAIR(i, ma))) return map[PAIR(i, ma)];
ll re = 0;
(re += rec(i + 1, q[i])) %= MOD;
(re += rec(i + 2, q[i])) %= MOD;
return map[PAIR(i, ma)] = re;
};
return rec(0, -1) % MOD;
}
signed main() {
INIT;
VAR(int, n);
VEC(int, q, n);
OUT(solve2(n, q))BR;
return 0;
}
|
#include <iostream>
using namespace std;
long long dp[100009], n, a[100009], mod = 1000000007;
bool prime[1000009];
int main() {
for (int i = 2; i <= 1000004; i++) prime[i] = true;
for (int i = 2; i <= 1000; i++) {
for (int j = i*i; j <= 1000000; j += i) prime[j] = false;
}
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
if (prime[a[1]] == false) {
cout << "0" << endl;
return 0;
}
a[n + 1] = 1000003;
dp[1] = 1;
for (int i = 1; i <= n; i++) {
if (a[i + 1] > a[i] && prime[a[i + 1]] == true) dp[i + 1] += dp[i];
if (a[i + 2] > a[i] && prime[a[i + 2]] == true) dp[i + 2] += dp[i];
dp[i + 1] %= mod; dp[i + 2] %= mod;
}
cout << dp[n + 1] << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define int long long
using namespace std;
bool prime[1000009];
void era(){
prime[0]=1;
prime[1]=1;
for(int i=2;i<1000009;i++){
if(!prime[i]){
for(int j=i+i;j<1000009;j+=i) prime[j]=1;
}
}
}
int dp[100009];
signed main(){
era();
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)cin>>a[i];
if(!prime[a[0]])dp[0]=1;
for(int i=0;i<n-1;i++){
if(!prime[a[i]]&&!prime[a[i+1]]&&a[i]<a[i+1])dp[i+1]+=dp[i];
if(i<n-2&&!prime[a[i]]&&!prime[a[i+2]]&&a[i]<a[i+2])dp[i+2]+=dp[i];
dp[i+1]%=1000000007;
dp[i+2]%=1000000007;
}
cout<<(dp[n-1]+dp[n-2])%1000000007<<endl;
}
|
#define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define PB push_back
const ll LLINF = (1LL<<60);
const int INF = (1LL<<30);
const int MOD = 1000000007;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a<=x&&x<b; }
template<typename T> T ceil(T a, T b) { return a/b + !!(a%b); }
template<class S,class T>
ostream &operator <<(ostream& out,const pair<S,T>& a){
out<<'('<<a.first<<','<<a.second<<')';
return out;
}
template<class T>
ostream &operator <<(ostream& out,const vector<T>& a){
out<<'[';
REP(i, a.size()) {out<<a[i];if(i!=a.size()-1)out<<',';}
out<<']';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
template<unsigned MOD>
class ModInt {
public:
unsigned x;
ModInt(): x(0) { }
ModInt(signed y) : x(y >= 0 ? y % MOD : MOD - (-y) % MOD) {}
unsigned get() const { return x; }
// 逆数
ModInt inv() const {
ll a = 1, p = x, e = MOD-2;
while(e > 0) {
if(e%2 == 0) {p = (p*p) % MOD; e /= 2;}
else {a = (a*p) % MOD; e--;}
}
a %= MOD;
return ModInt(a);
}
// e乗
ModInt pow(ll e) {
ll a = 1, p = x;
while(e > 0) {
if(e%2 == 0) {p = (p*p) % MOD; e /= 2;}
else {a = (a*p) % MOD; e--;}
}
a %= MOD;
return ModInt(a);
}
// 2のx乗
ModInt pow2() {
ll a = 1, p = 2, e = x;
while(e > 0) {
if(e%2 == 0) {p = (p*p) % MOD; e /= 2;}
else {a = (a*p) % MOD; e--;}
}
a %= MOD;
return ModInt(a);
}
// Comparators
bool operator <(ModInt b) { return x < b.x; }
bool operator >(ModInt b) { return x > b.x; }
bool operator<=(ModInt b) { return x <= b.x; }
bool operator>=(ModInt b) { return x >= b.x; }
bool operator!=(ModInt b) { return x != b.x; }
bool operator==(ModInt b) { return x == b.x; }
// increment, decrement
ModInt operator++() { x++; return *this; }
ModInt operator--() { x--; return *this; }
// Basic Operations
ModInt &operator+=(ModInt that) {
x = ((ll)x+that.x)%MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
x = ((((ll)x-that.x)%MOD)+MOD)%MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (ll)x * that.x % MOD;
return *this;
}
// O(log(mod))かかるので注意
ModInt &operator/=(ModInt that) {
x = (ll)x * that.inv() % MOD;
return *this;
}
ModInt &operator%=(ModInt that) {
x = (ll)x % that.x;
return *this;
}
ModInt operator+(ModInt that)const{return ModInt(*this) += that;}
ModInt operator-(ModInt that)const{return ModInt(*this) -= that;}
ModInt operator*(ModInt that)const{return ModInt(*this) *= that;}
ModInt operator/(ModInt that)const{return ModInt(*this) /= that;}
ModInt operator%(ModInt that)const{return ModInt(*this) %= that;}
};
typedef ModInt<1000000007> mint;
// Input/Output
ostream &operator<<(ostream& os, mint a) { return os << a.x; }
istream &operator>>(istream& is, mint &a) { return is >> a.x; }
bool prime[1000010];
mint dp[100010][2];
signed main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
VI q(n);
REP(i, n) cin >> q[i];
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for (int i = 2; i * i <= 1000010; i++) {
if (prime[i]) {
for (int j = 2 * i; j <= 1000010; j += i) {
prime[j] = false;
}
}
}
dp[0][1] = (prime[q[0]] ? 1 : 0);
FOR(i, 1, n) {
if(prime[q[i-1]]) dp[i][0] += dp[i-1][1];
if(prime[q[i]] && prime[q[i-1]] && q[i-1] < q[i]) dp[i][1] += dp[i-1][1];
if(i >= 2 && prime[q[i]] && prime[q[i-2]] && q[i-2] < q[i]) dp[i][1] += dp[i-1][0];
}
cout << dp[n-1][0] + dp[n-1][1] << endl;
return 0;
}
|
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <algorithm>
#include <array>
#include <bitset>
#include <assert.h>
using namespace std;
#define REP(i,n) for(int i=0; i<n; ++i)
#define FOR(i,a,b) for(int i=a; i<=b; ++i)
#define FORR(i,a,b) for (int i=a; i>=b; --i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef pair<int,int> P;
typedef pair<ll,ll> PL;
int in() { int x; scanf("%d", &x); return x; }
ll lin() { ll x; scanf("%lld", &x); return x; }
bool isprime(int x){
for (int y = 2; y * y <= x; y++){
if (x % y == 0) return false;
}
return true;
}
const ll mod = 1e9 + 7;
int main() {
int n;
cin >> n;
VI a(n);
REP(i,n) a[i] = in();
VI isp(n);
REP(i,n) isp[i] = isprime(a[i]);
VVI dp(n+2, VI(2));
if (isp[0]){
dp[1][0] = 1;
dp[2][1] = 1;
}
FOR(i,1,n-1) REP(j,2){
if (!isp[i]) continue;
if (a[i] <= a[i-j-1]) continue;
dp[i+1][0] = (dp[i+1][0] + dp[i][j]) % mod;
dp[i+2][1] = (dp[i+2][1] + dp[i][j]) % mod;
}
cout << (dp[n][0] + dp[n][1]) % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
//#define int long long
struct Fast {Fast(){std::cin.tie(0);ios::sync_with_stdio(false);}} fast;
/* cpp template {{{ */
/* short */
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define X real()
#define Y imag()
/* REPmacro */
#define REPS(i, a, n) for (ll i = (a); i < (ll)(n); ++i)
#define rep(i, n) REPS(i, 0, n)
#define REP0(i,n) for (ll i = 0; i <= (ll)(n); ++i)
#define REP1(i,n) for (ll i = 1; i <= (ll)(n); ++i)
#define RREP(i, n) REPS(i, 1, n + 1)
#define DEPS(i, a, n) for (ll i = (a); i >= (ll)(n); --i)
#define DEP(i, n) DEPS(i, n, 0)
#define EACH(i, n) for (auto&& i : n)
/* debug */
#define debug(x) cerr << x << " " << "(L:" << __LINE__ << ")" << '\n';
/* alias */
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
using D = double;
using P = complex<D>;
using vs = vector<string>;
template <typename T> using PQ = priority_queue<T>;
template <typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;
/* const */
const int INF = 1001001001;
const ll LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
const D EPS = 1e-9;
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1}, dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
/* func */
inline bool inside(int y, int x, int H, int W) {return y >= 0 && x >= 0 && y < H && x < W;}
inline int in() {int x; cin >> x; return x;}
inline ll IN() {ll x; cin >> x; return x;}
inline vs split(const string& t, char c) {vs v; stringstream s(t); string b; while(getline(s, b, c)) v.eb(b); return v;}
template <typename T> inline bool chmin(T& a, const T& b) {if (a > b) a = b; return a > b;}
template <typename T> inline bool chmax(T& a, const T& b) {if (a < b) a = b; return a < b;}
template <typename T, typename S> inline void print(const pair<T, S>& p) {cout << p.first << " " << p.second << endl;}
template <typename T> inline void print(const T& x) {cout << x << '\n';}
template <typename T, typename S> inline void print(const vector<pair<T, S>>& v) {for (auto&& p : v) print(p);}
template <typename T> inline void print(const vector<T>& v, string s = " ") {rep(i, v.size()) cout << v[i] << (i != (ll)v.size() - 1 ? s : "\n");}
template<typename T>
istream& operator >> (istream& is, vector<T>& vec){
for(T& x: vec) is >> x;
//for(int i=0; i<vec.size(); i++) is >> x[i]; とかでもいいです。
return is;
}
template<typename T>
ostream& operator << (ostream& os, vector<T>& vec){
for(int i=0; i<vec.size(); i++){
os << vec[i] << ( i+1 == vec.size() ? "" : " " );
}
return os;
}
/* }}} */
vector<long long int> dijkstra(int s,int v, vector<vector<pii>> G)
{
//s: 始点, v: 頂点数, G: 隣接リスト
PQ<pair<long long int,int>> wait;
vector<long long int> result(v,INF);
result[s]=0;
wait.push(mp(0,s));
while(!wait.empty())
{
long long int nowpoint=wait.top().Se;
long long int nowcost=wait.top().Fi;
wait.pop();
if(nowcost<=result[nowpoint])
{
rep(i,G[nowpoint].size())
{
long long int nextpoint=G[nowpoint][i].Se;
long long int nextcost= G[nowpoint][i].Fi-nowcost;
if(nextcost<result[nextpoint])
{
wait.push(mp(-nextcost,nextpoint));
result[nextpoint]=nextcost;
}
}
}
}
return result;
}
vector<bool> IsPrime;
void sieve(size_t max){
if(max+1 > IsPrime.size()){ // resizeで要素数が減らないように
IsPrime.resize(max+1,true); // IsPrimeに必要な要素数を確保
}
IsPrime[0] = false; // 0は素数ではない
IsPrime[1] = false; // 1は素数ではない
for(size_t i=2; i*i<=max; ++i) // 0からsqrt(max)まで調べる
if(IsPrime[i]) // iが素数ならば
for(size_t j=2; i*j<=max; ++j) // (max以下の)iの倍数は
IsPrime[i*j] = false; // 素数ではない
}
bool f(int a, int b)
{
if(IsPrime[a]&&(b<a)) return true;
else return false;
}
signed main()
{
sieve(1000001);
int n=in();
int q[n];
rep(i,n) cin>>q[i];
ll p,e,mp,me;
if(IsPrime[q[0]]) mp=q[0];
else
{
cout<<0<<endl;
return 0;
}
me=1;
p=1,e=0;
for(int i=1;i<n;++i)
{
ll tp,te,tmp,tme;
if(f(q[i],mp))
{
tp=p;
tmp=q[i];
te=p;
tme=mp;
}
else
{
tp=0;
tmp=mp;
te=p;
tme=mp;
}
if(f(q[i],me))
{
tp+=e%MOD;
tmp=q[i];
}
p=tp,e=te,mp=tmp,me=tme;
}
ll ans=(e+p)%MOD;
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
constexpr int M = 1e9 + 7;
int main() {
int N;
cin >> N;
vector<int> q(N);
vector<bool> b(N, false);
for(int i = 0; i < N; ++i) {
cin >> q[i];
for(int x = 2; x * x <= q[i]; ++x) {
if(q[i] % x == 0) b[i] = true;
}
}
// dp[i][pre is p]
vector<vector<int>> dp(N + 1, vector<int>(2));
dp[0][0] = 1;
for(int i = 0; i < N; ++i) {
if(i == 0 && !b[i]) {
dp[i + 1][1] = 1;
continue;
}
for(int j = 0; j < 2; ++j) {
if(j == 0) {
if((i < 2 || (q[i - 2] != q[i] && q[i - 2] < q[i]))
&& !b[i]) {
(dp[i + 1][1] += dp[i][j]) %= M;
}
} else { // pre is p
if(q[i - 1] == q[i]) {
(dp[i + 1][0] += dp[i][j]) %= M;
} else {
if(q[i - 1] < q[i] && !b[i]) {
(dp[i + 1][1] += dp[i][j]) %= M;
}
(dp[i + 1][0] += dp[i][j]) %= M;
}
}
}
}
int ans = (dp[N][0] + dp[N][1]) % M;
cout << ans << endl;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstring>
#include <math.h>
using namespace std;
typedef long long ll;
typedef double D;
typedef pair<int,int> P;
#define M 1000000007
#define F first
#define S second
#define PB push_back
ll n,dp[100005][2],a[100005];
bool p[1000005];
int main(void){
for(int i=2;i<=1000;i++)if(!p[i])for(int j=i*2;j<=1000000;j+=i)p[j]=true;
scanf("%lld",&n);
for(int i=0;i<n;i++)scanf("%lld",a+i);
if(!p[a[0]])dp[1][0]=1;
for(int i=1;i<n;i++){
dp[i+1][1]=(dp[i+1][1]+dp[i][0])%M;
if(!p[a[i]]&&a[i-1]<a[i])dp[i+1][0]=(dp[i+1][0]+dp[i][0])%M;
if(i>1&&!p[a[i]]&&a[i-2]<a[i])dp[i+1][0]=(dp[i+1][0]+dp[i][1])%M;
}
cout<<(dp[n][0]+dp[n][1])%M<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define pb emplace_back
typedef long long ll;
typedef pair<ll,ll> pint;
ll dp[100003];
const int max_n=1000001;
bool is_prime[max_n];
int prime[max_n];
int sieve(int n){
int p=0;
rep(i,n+1) is_prime[i]=true;
is_prime[0]=is_prime[1]=false;
FOR(i,2,n+1){
if(is_prime[i]){
prime[p++]=i;
for(int j=2*i;j<=n;j+=i) is_prime[j]=false;
}
}
return p;
}
int q[100001];
const int mod=1000000007;
int main(){
int n;
cin>>n;
sieve(1000000);
dp[0]=1;
rep(i,n) cin>>q[i];
rep(i,n){
if(i+2<=n&&is_prime[q[i]]&&(i+2==n||q[i+2]>q[i])){
dp[i+2]+=dp[i];
dp[i+2]%=mod;
}
if(is_prime[q[i]]&&(i+1==n||q[i+1]>q[i])){
dp[i+1]+=dp[i];
dp[i+1]%=mod;
}
}
cout<<dp[n]<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define FOR(i,a,b) for( ll i = (a); i < (ll)(b); i++ )
#define REP(i,n) FOR(i,0,n)
#define YYS(x,arr) for(auto& x:arr)
#define ALL(x) (x).begin(),(x).end()
#define SORT(x) sort( (x).begin(),(x).end() )
#define REVERSE(x) reverse( (x).begin(),(x).end() )
#define UNIQUE(x) (x).erase( unique( ALL( (x) ) ) , (x).end() )
#define PW(x) (1LL<<(x))
#define SZ(x) ((ll)(x).size())
#define SHOW(x) cout << #x << " = " << x << endl
#define SHOWA(x,n) for( int yui = 0; yui < n; yui++ ){ cout << x[yui] << " "; } cout << endl
#define pb emplace_back
#define fi first
#define se second
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef pair<int,int> pi;
typedef pair<ll,ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<bool> vb;
typedef vector<ld> vd;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<vpl> gr;
typedef vector<vl> ml;
typedef vector<vd> md;
typedef vector<vi> mi;
const ll INF = (ll)1e9 + 10;
const ll INFLL = (ll)1e18 + 10;
const ld EPS = 1e-12;
const ll MOD = 1e9+7;
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<class T> inline T sq( T a ){ return a * a; }
ll in(){ long long int x; scanf( "%lld" , &x ); return x; }
char yuyushiki[1000010]; string stin(){ scanf( "%s" , yuyushiki ); return yuyushiki; }
// head
struct Mod{
unsigned n;
Mod() : n(0){}
Mod( ll x ){
if( x < 0 ) n = x%MOD+MOD;
else n = x%MOD;
}
};
Mod operator + ( Mod a , Mod b ){ return Mod( a.n + b.n ); }
Mod operator +=( Mod &a , Mod b ){ return a = a + b; }
Mod operator - ( Mod a ){ return Mod( MOD - a.n ); }
Mod operator - ( Mod a , Mod b ){ return Mod( a.n + MOD - b.n ); }
Mod operator -=( Mod &a , Mod b ){ return a = a - b; }
Mod operator * ( Mod a , Mod b ){ return Mod( (ll)a.n * b.n ); }
Mod operator *=( Mod &a , Mod b ){ return a = a * b; }
Mod modpow( Mod x , ll k ){
Mod res = 1;
while( k ){
if( k & 1 ) res *= x;
k /= 2;
x *= x;
}
return res;
}
ll extgcd( ll a , ll b , ll &x , ll &y ){
ll d = a;
if( b != 0 ){
d = extgcd( b , a % b , y , x );
y -= a / b * x;
} else {
x = 1, y = 0;
}
return d;
}
Mod inv( Mod a ){ ll x, y; assert( extgcd( a.n , MOD , x , y ) == 1 ); return Mod( x ); }
Mod operator / ( Mod a , Mod b ){ return Mod( (ll)a.n * inv(b).n ); }
Mod operator /=( Mod &a , Mod b ){ return a = a / b; }
vb isp;
int max_p;
void init_p( int mp = 1000010 ){
max_p = mp;
isp.resize( max_p , true );
isp[0] = isp[1] = false;
FOR( i , 2 , max_p ){
if( isp[i] ){
for( int j = i*2; j < max_p; j += i )
isp[j] = false;
}
}
}
bool is_prime( int x ){
return isp[x];
}
int n;
int a[100010];
Mod dp[100010][2];
int main(){
init_p();
n = in();
a[0] = -1;
REP( i , n ){
a[i+1] = in();
}
dp[0][0] = 1;
REP( i , n ){
REP( j , 2 ){
if(dp[i][j].n != 0){
if(a[i-j] < a[i+1] && is_prime(a[i+1])){
// cout << "* " << i+1 << " " << 0 << " " << dp[i+1][0].n << " " << dp[i][j].n << endl;
dp[i+1][0] += dp[i][j];
if(i+2 <= n && a[i+2] >= 2){
dp[i+2][1] += dp[i][j];
//cout << "* " << i+2 << " " << 1 << " " << dp[i+1][0].n << " " << dp[i][j].n << endl;
}
}
}
}
}
/*
REP( i , n+1 ){
cout << dp[i][0].n << " " << dp[i][1].n << endl;
}
*/
Mod ans = dp[n][0] + dp[n][1];
cout << ans.n << endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define int long long // <-----!!!!!!!!!!!!!!!!!!!
#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n)-1;i>=0;i--)
#define rrep2(i,a,b) for (int i=(a)-1;i>=b;i--)
#define chmin(a,b) (a)=min((a),(b));
#define chmax(a,b) (a)=max((a),(b));
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define printV(v) cerr<<(#v)<<":";for(auto(x):(v)){cerr<<" "<<(x);}cerr<<endl;
#define printVS(vs) cerr<<(#vs)<<":"<<endl;for(auto(s):(vs)){cerr<<(s)<< endl;}
#define printVV(vv) cerr<<(#vv)<<":"<<endl;for(auto(v):(vv)){for(auto(x):(v)){cerr<<" "<<(x);}cerr<<endl;}
#define printP(p) cerr<<(#p)<<(p).first<<" "<<(p).second<<endl;
#define printVP(vp) cerr<<(#vp)<<":"<<endl;for(auto(p):(vp)){cerr<<(p).first<<" "<<(p).second<<endl;}
inline void output(){ cerr << endl; }
template<typename First, typename... Rest>
inline void output(const First& first, const Rest&... rest) {
cerr << first << " "; output(rest...);
}
using ll = long long;
using Pii = pair<int, int>;
using TUPLE = tuple<int, int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
const int inf = 1ll << 60;
const int mod = 1e9 + 7;
using Graph = vector<vector<int>>;
// x > 0
bool isPrime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return n != 1;
}
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n;
cin >> n;
vi a(n + 2);
a[0] = 1;
rep(i, n) cin >> a[i + 1];
a.back() = mod;
vi dp(n + 2, 0);
if (!isPrime(a[1])) {
cout << 0 << endl;
return 0;
}
dp[1] = 1;
rep2(i, 2, n + 2) {
if (isPrime(a[i])) {
if (a[i] > a[i - 1]) dp[i] += dp[i - 1];
if (a[i] > a[i - 2]) dp[i] += dp[i - 2];
dp[i] %= mod;
}
}
cout << dp.back() << endl;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
struct prime_num{
int number;
bool if_prime_num;
};
vector<prime_num> prime_nums;
long dp[int(2e5)];
long choose(int now){
if(dp[now] != -1){
return dp[now];
}else if(now >= int(prime_nums.size()) - 1){
return dp[now] = 1;
}else if(!prime_nums[now].if_prime_num && prime_nums[now].number < prime_nums[now + 1].number){
return dp[now] = choose(now + 1);
}else if(!prime_nums[now].if_prime_num){
return dp[now] = 0;
}else if(!prime_nums[now + 1].if_prime_num && prime_nums[now].number < prime_nums[now + 1].number){
return dp[now] = choose(now + 1);
}else if(!prime_nums[now + 1].if_prime_num){
return dp[now] = 0;
}else if(now == int(prime_nums.size()) - 2 && prime_nums[now].number < prime_nums[now + 1].number){
return dp[now] = 2;
}else if(now == int(prime_nums.size()) - 2){
return dp[now] = 1;
}else if(prime_nums[now].number < prime_nums[now + 1].number && prime_nums[now].number < prime_nums[now + 2].number){
return dp[now] = (choose(now + 1) + choose(now + 2)) % long(1e9 + 7);
}else if(prime_nums[now].number < prime_nums[now + 1].number){
return dp[now] = choose(now + 1);
}else if(prime_nums[now].number < prime_nums[now + 2].number){
return dp[now] = choose(now + 2);
}else{
return dp[now] = 0;
}
}
int main(){
int N;
cin >> N;
int if_prime[int(2e6)];
fill(if_prime, if_prime + int(2e6), -1);
if_prime[0] = 0;
if_prime[1] = 0;
for(int i = 2; i * i <= int(2e6); i++){
if(if_prime[i] == -1){
if_prime[i] = 1;
for(int j = i * 2; j < int(2e6); j += i){
if_prime[j] = 0;
}
}
}
int nums[N];
for(int i = 0; i < N; i++){
cin >> nums[i];
}
if(!if_prime[nums[0]]){
cout << 0 << endl;
return 0;
}
prime_nums.push_back({nums[0], true});
for(int i = 1; i < N; i++){
if(!if_prime[nums[i - 1]] && !if_prime[nums[i]]){
cout << 0 << endl;
return 0;
}else if(!if_prime[nums[i]] && prime_nums.empty()){
cout << 0 << endl;
return 0;
}else if(!if_prime[nums[i]]){
prime_num insert_item = {prime_nums.back().number, false};
prime_nums.pop_back();
prime_nums.push_back(insert_item);
}else{
prime_nums.push_back({nums[i], true});
}
}
fill(dp, dp + int(2e5), -1);
cout << choose(0) << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=1e9+7;
bool isPrime(ll x){
if(x<2)return false;
for(ll i=2;i*i<=x;i++)
if(x%i==0)return false;
return true;
}
int n;
ll a[100005];
ll dp[100005][2];
int main(){
cin>>n;
for(int i=1;i<=n;i++)cin>>a[i];
dp[0][0]=1;
for(int i=1;i<=n;i++){
if( isPrime(a[i]) ){
if(a[i] > a[i-1] &&i-1>=0){
dp[i][0]+=dp[i-1][0];
}
if(a[i] > a[i-2] &&i-2>=0){
dp[i][0]+=dp[i-1][1];
}
}
if( isPrime(a[i-1]) &&i-1>=0 ){
if( a[i-1] > a[i-2] &&i-2>=0){
dp[i][1]+=dp[i-2][0];
}
if( a[i-1] > a[i-3] &&i-3>=0){
dp[i][1]+=dp[i-2][1];
}
}
dp[i][0]%=mod;
dp[i][1]%=mod;
}
cout<< (dp[n][0]+dp[n][1]) % mod <<endl;
return 0;
}
|
#include <iostream>
#define int long long
using namespace std;
int n;
int q[100000];
bool isPrime[1000001];
void setPrime(int n) {
int i, j;
for (i = 2; i <= n; i++) isPrime[i] = true; isPrime[0] = isPrime[1] = false;
for (i = 2; i <= n; i++) {
if (isPrime[i]) {
for (j = i * 2; j <= n; j += i)
isPrime[j] = false;
}
}
}
int dp[100001];
int mod = 1000000007;
signed main() {
int i;
cin >> n;
for (i = 0; i < n; i++) cin >> q[i];
setPrime(1000000);
if (!isPrime[q[0]]) { cout << 0 << endl; return 0; }
dp[0] = 1;
for (i = 0; i < n; i++) {
if (i + 1 == n || (isPrime[q[i + 1]] && q[i] < q[i + 1])) {
dp[i + 1] += dp[i];
dp[i + 1] %= mod;
}
if (i == n - 1) continue;
if (i + 2 == n || (isPrime[q[i + 2]] && q[i] < q[i + 2])) {
dp[i + 2] += dp[i];
dp[i + 2] %= mod;
}
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void eratosthenes(int N, int* arr){
for(int i=0; i < N; i++){
arr[i] = 1;
}
for(int i=2; i < sqrt(N); i++){
if(arr[i]){
for(int j=0; i * (j + 2) < N; j++){
arr[i*(j+2)] = 0;
}
}
}
}
int main(void){
const int NMAX = 100011;
const int QMAX = 1000001;
const int MOD = 1e9+7;
int dp[NMAX][2]; // dp[idx][自分が素因数(0)か肩(1)か]
int isprime[QMAX];
for(int i = 0; i < NMAX; i++) for(int j = 0; j < 2; j++) dp[i][j] = 0;
eratosthenes(QMAX, isprime);
int N; cin >> N;
vector<int> q(N);
for(int i = 0; i < N; i++) cin >> q[i];
q.push_back(0);
if(isprime[q[0]])
dp[0][0] = 1;
for(int i = 0; i < N-1; i++){
for(int j = 0; j < 2; j++){
if(j == 0){
dp[i+1][1] = (dp[i+1][1] + dp[i][j]) % MOD;
if(q[i+1] > q[i] && isprime[q[i+1]]){
dp[i+1][0] = (dp[i+1][0] + dp[i][j]) % MOD;
}
}else{
if((i == 0 || q[i+1] > q[i-1]) && isprime[q[i+1]]){
dp[i+1][0] = (dp[i+1][0] + dp[i][j]) % MOD;
}
}
}
}
cout << (dp[N-1][0] + dp[N-1][1]) % MOD << endl;
return 0;
}
|
// {{{
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
// }}}
using ll = long long;
const ll MOD = 1000000007;
char prime[1000005];
void init_prime() {
fill(prime, prime+1000005, 1);
prime[0] = prime[1] = 0;
for (int x = 2; x <= 1000000; ++x) {
if (prime[x] && x <= 1000) {
for (int y = x*x; y <= 1000000; y += x) prime[y] = 0;
}
}
}
ll N, Q[101010];
ll memo[101010];
int main() {
init_prime();
cin.tie(0); ios::sync_with_stdio(false);
cin >> N;
for (int j = 1; j <= N; ++j) cin >> Q[j];
reverse(Q+1, Q+N+1);
fill(memo, memo+N+1, 0);
memo[0] = 1;
memo[1] = prime[Q[1]] ? 1 : 0;
for (int j = 2; j <= N; ++j) {
if (prime[Q[j]]) {
if (Q[j-1] > Q[j]) {
memo[j] = (memo[j] + memo[j-1]) % MOD;
}
if (Q[j-1] > 1 && (j < 3 || (prime[Q[j-2]] && Q[j-2] > Q[j]))) {
memo[j] = (memo[j] + memo[j-2]) % MOD;
}
}
}
cout << memo[N] << endl;
return 0;
}
|
/* -*- coding: utf-8 -*-
*
* 2870.cc: The Diversity of Prime Factorization
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
using namespace std;
/* constant */
const int MAX_N = 100000;
const int MAX_P = 1000000;
const int MOD = 1000000007;
/* typedef */
/* global variables */
bool primes[MAX_P + 1];
int qs[MAX_N], dp[MAX_N][2];
/* subroutines */
void gen_primes(int maxp) {
memset(primes, true, sizeof(primes));
primes[0] = primes[1] = false;
for (int p = 2; p * p <= maxp; p++)
if (primes[p])
for (int q = p * p; q <= maxp; q += p) primes[q] = false;
}
inline void addmod(int &a, int b) { a = (a + b) % MOD; }
/* main */
int main() {
gen_primes(MAX_P);
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", qs + i);
if (! primes[qs[0]]) {
puts("0");
return 0;
}
dp[0][0] = 1;
for (int i = 1; i < n; i++) {
if (primes[qs[i]]) {
if (primes[qs[i - 1]] && qs[i - 1] < qs[i])
addmod(dp[i][0], dp[i - 1][0]);
if (i >= 2 && primes[qs[i - 2]] && qs[i - 2] < qs[i])
addmod(dp[i][0], dp[i - 1][1]);
}
dp[i][1] = dp[i - 1][0];
}
//for (int i = 0; i < n; i++) printf("%d,%d ", dp[i][0], dp[i][1]);
printf("%d\n", (dp[n - 1][0] + dp[n - 1][1]) % MOD);
return 0;
}
|
#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<map>
#include<cstring>
#include<string>
#include <math.h>
#include<algorithm>
// #include <boost/multiprecision/cpp_int.hpp>
#include<functional>
#define int long long
#define inf 1000000007
#define pa pair<int,int>
#define ll long long
#define pal pair<double,double>
#define ppap pair<pa,int>
#define ssa pair<string,int>
#define mp make_pair
#define pb push_back
#define EPS (1e-10)
#define equals(a,b) (fabs((a)-(b))<EPS)
int dx[4]={0,-1,0,1};
int dy[4]={1,0,-1,0};
using namespace std;
class pa3{
public:
int x,y,z;
pa3(int x=0,int y=0,int z=0):x(x),y(y),z(z) {}
bool operator < (const pa3 &p) const{
if(x!=p.x) return x<p.x;
if(y!=p.y) return y<p.y;
return z<p.z;
//return x != p.x ? x<p.x: y<p.y;
}
bool operator > (const pa3 &p) const{
if(x!=p.x) return x>p.x;
if(y!=p.y) return y>p.y;
return z>p.z;
//return x != p.x ? x<p.x: y<p.y;
}
bool operator == (const pa3 &p) const{
return x==p.x && y==p.y && z==p.z;
}
bool operator != (const pa3 &p) const{
return !( x==p.x && y==p.y && z==p.z);
}
};
class pa4{
public:
double x;
int y,z,w;
pa4(double x=0,int y=0,int z=0,int w=0):x(x),y(y),z(z),w(w) {}
bool operator < (const pa4 &p) const{
if(x!=p.x) return x<p.x;
if(y!=p.y) return y<p.y;
if(z!=p.z)return z<p.z;
return w<p.w;
//return x != p.x ? x<p.x: y<p.y;
}
bool operator > (const pa4 &p) const{
if(x!=p.x) return x>p.x;
if(y!=p.y) return y>p.y;
if(z!=p.z)return z>p.z;
return w>p.w;
//return x != p.x ? x<p.x: y<p.y;
}
bool operator == (const pa4 &p) const{
return x==p.x && y==p.y && z==p.z &&w==p.w;
}
};
class pa2{
public:
int x,y;
pa2(int x=0,int y=0):x(x),y(y) {}
pa2 operator + (pa2 p) {return pa2(x+p.x,y+p.y);}
pa2 operator - (pa2 p) {return pa2(x-p.x,y-p.y);}
bool operator < (const pa2 &p) const{
return x != p.x ? x<p.x: y<p.y;
}
bool operator > (const pa2 &p) const{
return x != p.x ? x>p.x: y>p.y;
}
bool operator == (const pa2 &p) const{
return abs(x-p.x)==0 && abs(y-p.y)==0;
}
bool operator != (const pa2 &p) const{
return !(abs(x-p.x)==0 && abs(y-p.y)==0);
}
};
#define ppa pair<int,pas>
class Point{
public:
double x,y;
Point(double x=0,double y=0):x(x),y(y) {}
Point operator + (Point p) {return Point(x+p.x,y+p.y);}
Point operator - (Point p) {return Point(x-p.x,y-p.y);}
Point operator * (double a) {return Point(x*a,y*a);}
Point operator / (double a) {return Point(x/a,y/a);}
double absv() {return sqrt(norm());}
double norm() {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 fabs(x-p.x)<EPS && fabs(y-p.y)<EPS;
}
};
typedef Point Vector;
#define pl pair<int,pas>
struct Segment{
Point p1,p2;
};
double dot(Vector a,Vector b){
return a.x*b.x+a.y*b.y;
}
double cross(Vector a,Vector b){
return a.x*b.y-a.y*b.x;
}
bool parareru(Point a,Point b,Point c,Point d){
// if(abs(cross(a-b,d-c))<EPS)cout<<"dd "<<cross(a-b,d-c)<<endl;
return abs(cross(a-b,d-c))<EPS;
}
double distance_ls_p(Point a, Point b, Point c) {
if ( dot(b-a, c-a) < EPS ) return (c-a).absv();
if ( dot(a-b, c-b) < EPS ) return (c-b).absv();
return abs(cross(b-a, c-a)) / (b-a).absv();
}
bool is_intersected_ls(Segment a,Segment b) {
if(a.p1==b.p1||a.p2==b.p1||a.p1==b.p2||a.p2==b.p2) return false;
if(parareru((a.p2),(a.p1),(a.p1),(b.p2))&¶reru((a.p2),(a.p1),(a.p1),(b.p1))){
// cout<<"sss"<<endl;
if(dot(a.p1-b.p1,a.p1-b.p2)<EPS) return true;
if(dot(a.p2-b.p1,a.p2-b.p2)<EPS) return true;
if(dot(a.p1-b.p1,a.p2-b.p1)<EPS) return true;
if(dot(a.p1-b.p2,a.p2-b.p2)<EPS) return true;
return false;
}
else return ( cross(a.p2-a.p1, b.p1-a.p1) * cross(a.p2-a.p1, b.p2-a.p1) < EPS ) && ( cross(b.p2-b.p1, a.p1-b.p1) * cross(b.p2-b.p1, a.p2-b.p1) < EPS );
}
double segment_dis(Segment a,Segment b){
if(is_intersected_ls(a,b))return 0;
double r=distance_ls_p(a.p1, a.p2, b.p1);
r=min(r,distance_ls_p(a.p1, a.p2, b.p2));
r=min(r,distance_ls_p(b.p1, b.p2, a.p2));
r=min(r,distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2-b.p1;
double d1 = abs(cross(ba, a.p1-b.p1));
double d2 = abs(cross(ba, a.p2-b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2-a.p1) * t;
}
string itos( int i ) {
ostringstream s ;
s << i ;
return s.str() ;
}
int gcd(int v,int b){
if(v>b) return gcd(b,v);
if(v==b) return b;
if(b%v==0) return v;
return gcd(v,b%v);
}
double distans(double x1,double y1,double x2,double y2){
double rr=(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
return sqrt(rr);
}
// int pr[2000010];
// int inv[2000010];
int beki(int wa,int rr,int warukazu){
if(rr==0) return 1%warukazu;
if(rr==1) return wa%warukazu;
if(rr%2==1) return (beki(wa,rr-1,warukazu)*wa)%warukazu;
int zx=beki(wa,rr/2,warukazu);
return (zx*zx)%warukazu;
}
double bekid(double w,int r){
if(r==0) return 1.0;
if(r==1) return w;
if(r%2) return bekid(w,r-1)*w;
double f=bekid(w,r/2);
return f*f;
}
/*
int comb(int nn,int rr){
int r=pr[nn]*inv[rr];
r%=inf;
r*=inv[nn-rr];
r%=inf;
return r;
}
void gya(int ert){
pr[0]=1;
for(int i=1;i<ert;i++){
pr[i]=(pr[i-1]*i)%inf;
}
for(int i=0;i<ert;i++) inv[i]=beki(pr[i],inf-2,inf);
}
*/
//priority_queue<pa3,vector<pa3>,greater<pa3>> pq;
//sort(ve.begin(),ve.end(),greater<int>());
//----------------kokomade tenpure------------
//vector<double> ans(100000000),ans2(100000000)
int sosu[1000020]={0};
int q[100002];
int dp1[100020][2]={0};
int dp2[100020][2]={0};
signed main(){
int n,m;
sosu[1]=0;
for(int i=2;i<=1000000;i++){
if(sosu[i]) continue;
for(int j=2*i;j<=1000000;j+=i)sosu[j]=1;
}
cin>>n;
for(int i=1;i<=n;i++)cin>>q[i];
dp1[0][0]=1;
dp1[0][1]=1;
dp2[0][0]=1;
dp2[0][1]=1;
for(int i=1;i<n;i++){
if(sosu[q[i]]==1 && sosu[q[i+1]]==1){
cout<<0<<endl;
return 0;
}
}
q[0]=1;
for(int i=1;i<=n;i++){
if(sosu[q[i]]==0){
if(sosu[q[i-1]]==0)if( q[i-1]<q[i]){
dp1[i][0]+=dp1[i-1][0];
dp1[i][1]=q[i];
}
if(sosu[q[i-2]]==0)if(q[i-2]<q[i] && i>=3){
dp1[i][0]+=dp2[i-1][0];
dp1[i][1]=q[i];
}
dp1[i][0]%=inf;
}
if(sosu[q[i-1]]==0){
if(sosu[q[i-2]]==0)if(q[i-2]<q[i-1] && i>=2){
dp2[i][0]+=dp1[i-2][0];
dp2[i][1]=q[i-1];
}
if(sosu[q[i-3]]==0)if(q[i-3]<q[i-1] && i>=4){
dp2[i][0]+=dp2[i-2][0];
dp2[i][1]=q[i-1];
}
dp2[i][0]%=inf;
}
// cout<<dp1[i][0]<<" "<<dp2[i][0]<<endl;
// cout<<dp1[i][1]<<" "<<dp2[i][1]<<endl;
}
cout<<(dp1[n][0]+dp2[n][0])%inf<<endl;
return 0;
}
|
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define NUM 1010000
enum Type{
prime,
mult,
};
bool is_prime[NUM];
ll table[100001];
ll dp[100001][2];
int main(){
for(int i = 0; i < NUM; i++)is_prime[i] = true;
is_prime[0] = false;
is_prime[1] = false;
for(int i = 2; i <= sqrt(NUM); i++){
if(is_prime[i]){
for(int k = 2*i; k < NUM; k += i){
is_prime[k] = false;
}
}
}
int N;
scanf("%d",&N);
for(int i = 0; i < N; i++)scanf("%lld",&table[i]);
if(!is_prime[table[0]]){
printf("0\n");
return 0;
}
for(int i = 0; i < N; i++){
dp[i][prime] = 0;
dp[i][mult] = 0;
}
dp[0][prime] = 1;
for(int i = 1; i <= N-1; i++){
dp[i][mult] += dp[i-1][prime];
if(is_prime[table[i]]){
if(table[i-1] < table[i] && is_prime[table[i-1]] == true){
dp[i][prime] += dp[i-1][prime];
}
if(i >= 2 && table[i-2] < table[i] && is_prime[table[i-2]] == true){
dp[i][prime] += dp[i-1][mult];
}
}
dp[i][mult] %= MOD;
dp[i][prime] %= MOD;
}
ll ans = dp[N-1][prime]+dp[N-1][mult];
ans %= MOD;
printf("%lld\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
#define syosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<string> vs;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef vector<pll> vpll;
typedef pair<P,int> pip;
typedef vector<pip> vip;
const int inf=1<<30;
const ll INF=1ll<<60;
const double pi=acos(-1);
const double eps=1e-8;
const ll mod=1e9+7;
const int dx[4]={-1,0,1,0},dy[4]={0,-1,0,1};
bool Is_Prime(ll n){
for(int i=2;i*i<=n;i++){
if(n%i==0) return 0;
}
return n!=1;
}
int n;
vi a,b;
int main(){
cin>>n;
a=b=vi(n);
for(int i=0;i<n;i++){
cin>>a[i];
b[i]=Is_Prime(a[i]);
}
vi dp0(n),dp1(n);
if(b[0]) dp0[0]++;
if(n>=2&&b[0]) dp1[1]++;
for(int i=1;i<n;i++){
if(b[i]){
if(i-2>=0&&b[i-2]&&a[i-2]<a[i]) (dp0[i]+=dp1[i-1])%=mod;
if(b[i-1]&&a[i-1]<a[i]) (dp0[i]+=dp0[i-1])%=mod;
}
if(b[i-1]){
if(i-2>=0&&b[i-2]&&a[i-2]<a[i-1]) (dp1[i]+=dp0[i-2])%=mod;
if(i-3>=0&&b[i-3]&&a[i-3]<a[i-1]) (dp1[i]+=dp1[i-2])%=mod;
}
}
cout<<(dp0[n-1]+dp1[n-1])%mod<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,k,n) for(int i = (int)(k); i < (int)(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))
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
const int MOD = 1e9 + 7;
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<class T>
istream& operator >> (istream& is, vector<T>& v)
{
for (auto &i : v) is >> i;
return is;
}
template<class T>
ostream& operator<<(ostream& os, vector<T>& v)
{
const string delimiter = "\n";
REP(i, v.size())
{
os << v[i];
if (i != v.size() - 1) os << delimiter;
}
return os;
}
/*--------------------template--------------------*/
const int N = 1111111;
bool prime[N + 1];
vector<int> primes;
void hurui()
{
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for (int i = 2; i*i < N; i++)
{
if (!prime[i]) continue;
for (int j = i; i*j < N; j++)
{
prime[i*j] = false;
}
}
REP(i, N + 1)
{
if (prime[i])
{
primes.push_back(i);
}
}
}
ll pow(ll x, ll n, ll mod)
{
ll res = 1;
while (n > 0)
{
if (n & 1) res = res * x % mod;
x = x*x%mod;
n >>= 1;
}
return res;
}
int n;
vi q;
ll dp[111111];
ll solve(int p)
{
if (dp[p] >= 0) return dp[p];
if (p == n) return 0;
if (p == n - 1)
{
if (prime[q[p]]) return 1;
else return 0;
}
ll res = 0;
if (prime[q[p + 1]] && q[p + 1] > q[p])
{
res += solve(p + 1);
}
if (p + 2 < n && prime[q[p + 2]] && q[p + 2] > q[p])
{
res += solve(p + 2);
}
if (p + 2 == n)
{
res += 1;
}
return dp[p] = res % MOD;
}
int main()
{
cin.sync_with_stdio(false); cout << fixed << setprecision(10);
MS(dp, -1);
hurui();
cin >> n;
q.resize(n);
cin >> q;
if(prime[q[0]]) cout << solve(0) << endl;
else cout << 0 << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define all(c) c.begin(),c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
using namespace std;
template<class S,class T> ostream& operator<<(ostream& o,const pair<S,T> &p){return o<<"("<<p.fs<<","<<p.sc<<")";}
template<class T> ostream& operator<<(ostream& o,const vector<T> &vc){o<<"sz = "<<vc.size()<<endl<<"[";for(const T& v:vc) o<<v<<",";o<<"]";return o;}
typedef long long ll;
const ll ccc=1000000;
bool prime[ccc+1];
vector<ll> pr;
void makeprime(){
ll i,j;
for(i=2;i<=ccc;i++) prime[i]=true;
for(i=2;i*i<=ccc;i++) if(prime[i]) for(j=2;j*i<=ccc;j++) prime[j*i]=false;
for(i=2;i<=ccc;i++) if(prime[i]) pr.push_back(i);
}
template<unsigned int mod_>
struct ModInt{
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr static uint mod = mod_;
uint v;
ModInt():v(0){}
ModInt(ll v):v(normS(v%mod+mod)){}
explicit operator bool() const {return v!=0;}
static uint normS(const uint &x){return (x<mod)?x:x-mod;} // [0 , 2*mod-1] -> [0 , mod-1]
static ModInt make(const uint &x){ModInt m; m.v=x; return m;}
ModInt operator+(const ModInt& b) const { return make(normS(v+b.v));}
ModInt operator-(const ModInt& b) const { return make(normS(v+mod-b.v));}
ModInt operator-() const { return make(normS(mod-v)); }
ModInt operator*(const ModInt& b) const { return make((ull)v*b.v%mod);}
ModInt operator/(const ModInt& b) const { return *this*b.inv();}
ModInt& operator+=(const ModInt& b){ return *this=*this+b;}
ModInt& operator-=(const ModInt& b){ return *this=*this-b;}
ModInt& operator*=(const ModInt& b){ return *this=*this*b;}
ModInt& operator/=(const ModInt& b){ return *this=*this/b;}
ll extgcd(ll a,ll b,ll &x,ll &y) const{
ll u[]={a,1,0},v[]={b,0,1};
while(*v){
ll t=*u/ *v;
rep(i,3) swap(u[i]-=t*v[i],v[i]);
}
if(u[0]<0) rep(i,3) u[i]=-u[i];
x=u[1],y=u[2];
return u[0];
}
ModInt inv() const{
ll x,y;
extgcd(v,mod,x,y);
return make(normS(x+mod));
}
bool operator==(const ModInt& b) const { return v==b.v;}
bool operator!=(const ModInt& b) const { return v!=b.v;}
friend istream& operator>>(istream &o,ModInt& x){
ll tmp;
o>>tmp;
x=ModInt(tmp);
return o;
}
friend ostream& operator<<(ostream &o,const ModInt& x){ return o<<x.v;}
};
using mint = ModInt<1000000007>;
int main(){
makeprime();
int N;
cin>>N;
mint a=1,b=0,c=0;
vector<int> xs(N);
rep(i,N) cin>>xs[i];
rep(i,N){
int x = xs[i];
mint na = 0, nb = 0, nc = 0;
if(prime[x] && (i-2<0||xs[i-2]<xs[i])){
nb += a;
nc += a;
}
if(prime[x] && (i-1<0||xs[i-1]<xs[i])){
nb += b;
nc += c;
}
{
na += c;
}
a = na,b = nb,c = nc;
}
cout<<a+b<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define pb emplace_back
typedef long long ll;
typedef pair<ll,ll> pint;
ll dp[100003];
const int max_n=1000001;
bool is_prime[max_n];
int sieve(int n){
int p=0;
rep(i,n+1) is_prime[i]=true;
is_prime[0]=is_prime[1]=false;
FOR(i,2,n+1){
if(is_prime[i]){
for(int j=2*i;j<=n;j+=i) is_prime[j]=false;
}
}
return p;
}
int q[100001];
const int mod=1000000007;
int main(){
int n;
cin>>n;
sieve(1000000);
dp[0]=1;
rep(i,n) cin>>q[i];
rep(i,n){
if(i+2<=n&&is_prime[q[i]]&&(i+2==n||q[i+2]>q[i])){
dp[i+2]+=dp[i];
dp[i+2]%=mod;
}
if(is_prime[q[i]]&&(i+1==n||q[i+1]>q[i])){
dp[i+1]+=dp[i];
dp[i+1]%=mod;
}
}
cout<<dp[n]<<endl;
return 0;
}
|
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
#pragma GCC optimize ("-O3")
using namespace std; void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
typedef long long ll; const int inf = INT_MAX / 2; const ll infl = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a = b; return 1; } return 0; }
//---------------------------------------------------------------------------------------------------
template<int MOD> struct ModInt {
static const int Mod = MOD; unsigned x; ModInt() : x(0) { }
ModInt(signed sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
ModInt(signed long long sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) { if ((x += that.x) >= MOD) x -= MOD; return *this; }
ModInt &operator-=(ModInt that) { if ((x += MOD - that.x) >= MOD) x -= MOD; return *this; }
ModInt &operator*=(ModInt that) { x = (unsigned long long)x * that.x % MOD; return *this; }
ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt inverse() const { long long a = x, b = MOD, u = 1, v = 0;
while (b) { long long t = a / b; a -= t * b; std::swap(a, b); u -= t * v; std::swap(u, v); }
return ModInt(u); }
bool operator==(ModInt that) const { return x == that.x; }
bool operator!=(ModInt that) const { return x != that.x; }
ModInt operator-() const { ModInt t; t.x = x == 0 ? 0 : Mod - x; return t; }
};
template<int MOD> ostream& operator<<(ostream& st, const ModInt<MOD> a) { st << a.get(); return st; };
template<int MOD> ModInt<MOD> operator^(ModInt<MOD> a, unsigned long long k) {
ModInt<MOD> r = 1; while (k) { if (k & 1) r *= a; a *= a; k >>= 1; } return r; }
typedef ModInt<1000000007> mint;
bool isprime(int v) {
if (v == 1) return false;
for (int i = 2; 1LL*i*i <= v; i++) if (v%i == 0) return false;
return true;
}
/*---------------------------------------------------------------------------------------------------
∧＿∧
∧＿∧ （´<_｀ ） Welcome to My Coding Space!
（ ´_ゝ`） / ⌒i
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
---------------------------------------------------------------------------------------------------*/
/*
合成数は累乗にするしかない
前回のpは最低2個前
*/
int N, A[101010];
mint dp[101010][3];
// dp[i][j] := i番目まででj個前がpとして使われている
//---------------------------------------------------------------------------------------------------
void _main() {
cin >> N;
rep(i, 0, N) cin >> A[i];
if (!isprime(A[0])) {
printf("0\n");
return;
}
dp[1][1] = 1;
rep(i, 1, N) rep(j, 1, 3) {
// 新しくpを作る
if (isprime(A[i]) and 0<=i-j and A[i - j] < A[i]) dp[i + 1][1] += dp[i][j];
// 累乗にする
if (j == 1) dp[i + 1][2] += dp[i][j];
}
mint ans = dp[N][1] + dp[N][2];
cout << ans << endl;
}
|
#include<iostream>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define mod 1000000007
using namespace std;
bool prime[1000010];
long long dp[1000000];
int q[1000000];
int main(){
rep(i,1000000)prime[i]=true;
prime[0]=prime[1]=false;
loop(i,2,1000000){
for(int j=2*i;j<1000000;j+=i)prime[j]=false;
}
int n;
cin>>n;
rep(i,n)cin>>q[i];
dp[1]=(prime[q[0]]?1:0);
loop(i,1,n+1){
dp[i]%=mod;
if(prime[q[i+1]]&&q[i-1]<q[i+1])dp[i+2]+=dp[i];
if(prime[q[i]]&&q[i-1]<q[i])dp[i+1]+=dp[i];
}
cout<<(dp[n]+dp[n-1])%mod<<endl;
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <complex>
#include <functional>
#include <cassert>
typedef long long ll;
using namespace std;
#define debug(x) cerr << #x << " = " << (x) << endl;
#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 100010
const int MAX_P = 1000000; //max
bool prime[MAX_P+1];
void Eratosthenes(void){
for(int i=2;i<=MAX_P;i++)
prime[i]=true;
for(int i=2;i*i<=MAX_P;i++)
if(prime[i])
for(int j=i;i*j<=MAX_P;j++)
prime[i*j]=false;
}
int dp[SIZE][2];
int main(){
int n;
int q[SIZE];
Eratosthenes();
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d",q+i);
}
q[0] = 1;
dp[0][0] = 1;
for(int i=0;i<n;i++){
if(prime[q[i+1]]){
if(i < n-1){
if(q[i] < q[i+1]) dp[i+2][1] = (dp[i+2][1] + dp[i][0])%mod;
if(i > 0 && q[i-1] < q[i+1]) dp[i+2][1] = (dp[i+2][1] + dp[i][1])%mod;
}
if(q[i] < q[i+1]) dp[i+1][0] = (dp[i+1][0] + dp[i][0])%mod;
if(i > 0 && q[i-1] < q[i+1]) dp[i+1][0] = (dp[i+1][0] + dp[i][1])%mod;
}
}
printf("%d\n",(dp[n][0] + dp[n][1])%mod);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
//INSERT ABOVE HERE
signed main(){
const Int MAX = 1e6+10;
vector<Int> p(MAX,0);
for(Int i=2;i<MAX;i++){
if(p[i]) continue;
for(Int j=i+i;j<MAX;j+=i) p[j]=1;
}
Int n;
cin>>n;
vector<Int> q(n);
for(Int i=0;i<n;i++) cin>>q[i];
vector<Int> dp(n+1,0);
const Int MOD = 1e9+7;
dp[0]=!p[q[0]];
for(Int i=0;i<n;i++){
if(i+1==n) (dp[i+1]+=dp[i])%=MOD;
if(i+2==n) (dp[i+2]+=dp[i])%=MOD;
if(i+1<n&&!p[q[i+1]]&&q[i]<q[i+1]) (dp[i+1]+=dp[i])%=MOD;
if(i+2<n&&!p[q[i+2]]&&q[i]<q[i+2]) (dp[i+2]+=dp[i])%=MOD;
}
cout<<dp[n]<<endl;
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
int main(){
bool np[1000001] = {};
np[0] = np[1] = true;
for(int i = 2; i < 1000001; i++){
if(np[i]) continue;
for(int j = i+i; j < 1000001; j += i) np[j] = true;
}
int n;
cin >> n;
vector<int> q(n);
for(int i = 0; i < n; i++) cin >> q[i];
if(np[q[0]]){
cout << 0 << endl;
return 0;
}
if(n == 1){
cout << 1 << endl;
return 0;
}
vector<vector<ll>> dp(2, vector<ll>(n,0));
dp[1][0] = 1;
dp[0][1] = 1;
if(!np[q[1]] && q[1] > q[0]) dp[1][1] = 1;
for(int i = 2; i < n; i++){
// 指数の肩ver
if(!np[q[i-1]]) dp[0][i] = (dp[0][i] + dp[1][i-1]) % mod;
// 素数ver
if(!np[q[i]]){
if(!np[q[i-1]] && q[i] > q[i-1]) dp[1][i] = (dp[1][i] + dp[1][i-1]) % mod;
if(!np[q[i-2]] && q[i] > q[i-2]) dp[1][i] = (dp[1][i] + dp[1][i-2]) % mod;
}
}
cout << (dp[0][n-1]+dp[1][n-1])%mod << endl;
return 0;
}
|
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
using namespace std;
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
typedef double ld;
typedef complex<ld> Point;
const ll INF = mod * mod;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(iinclude<snt i=sta;i<=n;i++)
const ld eps = 1e-6;
const ld pi = acos(-1.0);
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;
typedef pair<int, P> speP;
int dx[4] = { 1,0,-1,0 };
int dy[4] = { 0,1,0,-1 };
int h, w;
char mp[50][50];
int d[50][50];
void solve() {
int n;
cin >> n;
vector<int> a(n+1);
rep(i, n)cin >> a[i+1];
vector<ll> dp(n+1), dp2(n+1);
vector<int> isprime(1000001, 1);
isprime[0] = isprime[1] = 0;
for (int i = 2; i <= 1000000; ++i) {
if (!isprime[i])continue;
for (int j = 2 * i; j <= 1000000; j += i) {
isprime[j] = false;
}
}
dp[0] = 1;
rep(i, n) {
dp[i + 1] += dp2[i];
if (a[i + 1] > a[i] && isprime[a[i + 1]])(dp2[i + 1] += dp2[i])%=mod;
if (i >= 1 && a[i + 1] > a[i - 1] && isprime[a[i + 1]])(dp2[i + 1] += dp[i]) %= mod;
if (i ==0 && isprime[a[i + 1]])dp2[i + 1] += dp[i];
}
cout << (dp[n] + dp2[n]) % mod << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
stop
return 0;
}
|
#include <bits/stdc++.h>
#include <iomanip>
using namespace std;
typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<LD, LD> PLDLD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<char> VB;
#define FOR(i,a,b) for(int i=(a);i<(int)(b);++i)
#define REP(i,n) FOR(i,0,n)
#define CLR(a) memset((a), 0 ,sizeof(a))
#define ALL(a) a.begin(),a.end()
const LD eps=1e-10;
const long long INFLL=(LL)(1e9)*(LL)(1e9);
const int INF=1e9;
template<class T>
void chmin(T& a, const T b)
{
if(a>b)
a=b;
}
template<class T>
void chmax(T& a, const T b)
{
if(a<b)
a=b;
}
const LL pow(const LL p, const LL q)
{
LL t=1;
for(int i=0;i<q;i++)
t*=p;
return t;
}
template <typename T>
struct has_iter
{
private:
template <typename U>
static constexpr true_type check(typename U::iterator*);
template <typename U>
static constexpr false_type check(...);
public:
static constexpr bool value = decltype(check<T>(nullptr))::value;
};
template<typename T, typename U = typename T::iterator>
void print(const T& container)
{
auto&& first=begin(container), last=end(container);
auto&& back=prev(last);
for(auto e=first; e!=last; e=next(e))
cout<<*e<<" \n"[e==back];
}
extern void* enabler;
template<typename Head, typename enable_if<!has_iter<Head>::value>::type*& = enabler>
void print(const Head& head)
{
cout<<head<<endl;
}
template<typename Head, typename... Tail>
void print(const Head& head, const Tail&... tail)
{
cout<<head<<" ";
print(tail...);
}
void io_speedup()
{
cin.tie(0);
ios::sync_with_stdio(false);
}
template<typename T>
istream& operator >> (istream& is, vector<T>& vec)
{
for(T& x: vec) is >> x;
return is;
}
template<typename T>
vector<T> read(int n)
{
vector<T> t(n);
cin>>t;
return t;
}
template<typename T>
T read()
{
T t;
cin>>t;
return t;
}
class Mod
{
private:
static const long long MODULO = 1e9+7;
long long value;
const void Normalize()
{
value=value<0?(value%MODULO+MODULO):(value%MODULO);
}
public:
Mod():value(0){}
Mod(const long long &val)
{
value=val;
Normalize();
}
explicit operator long long () const
{
return value;
}
const Mod operator -() const
{
return Mod(MODULO - value);
}
const Mod operator +(const Mod &rhs) const
{
return Mod(value + rhs.value);
}
const Mod operator -(const Mod &rhs) const
{
return Mod(value + (-rhs).value);
}
const Mod operator *(const Mod &rhs) const
{
return Mod(value * rhs.value);
}
Mod &operator +=(const Mod &rhs)
{
return *this = *this + rhs;
}
Mod &operator -=(const Mod &rhs)
{
return *this = *this - rhs;
}
Mod &operator *=(const Mod &rhs)
{
return *this = *this * rhs;
}
Mod pow(long long p) const;
Mod inv() const
{
return pow(MODULO-2);
}
const Mod operator /(const Mod &rhs) const
{
return *this * rhs.inv();
}
Mod &operator /=(const Mod &rhs)
{
return *this = *this / rhs;
}
bool operator ==(const Mod &rhs)
{
return value == rhs.value;
}
};
Mod Mod::pow(long long p) const
{
Mod tmp=1, mult=*this;
while(p)
{
if((p&1)>0) tmp*=mult;
p>>=1;
mult*=mult;
}
return tmp;
}
namespace std
{
ostream& operator<<(ostream& os, const Mod mod)
{
os<<(long long)mod;
return os;
}
};
int main()
{
const int N=1000010;
vector<char> is_prime(N+1,1);
is_prime[0]=0;
is_prime[1]=0;
for(int i=2;i<N+1;i++)
{
if(!is_prime[i]) continue;
for(int j=i+i;j<N+1;j+=i)
is_prime[j]=0;
}
/*
REP(i,100)
{
if(is_prime[i])
print(i);
}*/
int n;
cin>>n;
vector<int> q(n+1);
q[0]=1;
REP(i,n)
cin>>q[i+1];
vector<vector<Mod>> dp(n+1, vector<Mod>(2));
dp[0][0]=1;
REP(i,n)
{
if(is_prime[q[i+1]])
{
//print("Yes");
if(q[i]<q[i+1])
dp[i+1][0] += dp[i][0];
if(q[i]<q[i+1] && i+2<n+1)
dp[i+2][1] += dp[i][0];
if(i-1<=0) continue;
if(q[i-1]<q[i+1])
dp[i+1][0] += dp[i][1];
if(q[i-1]<q[i+1] && i+2<n+1)
dp[i+2][1] += dp[i][1];
}
}
print(dp[n][0] + dp[n][1]);
/*REP(j,2)
{
REP(i,n+1)
cout<<dp[i][j]<<" \n"[i==n];
}*/
}
|
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int mod = 1e9+7;
int n, q[100005];
int prime[1000005];
int dp[100005];
signed main(){
for(int i=0;i<1000005;i++) prime[i] = 1;
prime[0] = prime[1] = 0;
for(int i=1;i*i<1000005;i++){
if(prime[i]==0) continue;
for(int j=i*2;j<1000005;j+=i) prime[j] = 0;
}
cin>>n;
for(int i=0;i<n;i++) cin>>q[i];
dp[0] = 1;
for(int i=0;i<n;i++){
if( prime[q[i]] == 0 ) continue;
if( i == n-1 ){
dp[i+1] += dp[i];
dp[i+1] %= mod;
continue;
}
if(q[i]<q[i+1]){
dp[i+1] += dp[i];
dp[i+1] %= mod;
}
if( i+2 == n ){
dp[i+2] += dp[i];
dp[i+2] %= mod;
}
else if(q[i]<q[i+2]){
dp[i+2] += dp[i];
dp[i+2] %= mod;
}
}
cout<<dp[n]<<endl;
return 0;
}
|
//#include <bits/stdc++.h>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <stack>
#include <queue>
#include <deque>
#include <cstring>
#include <string>
#include <utility>
#include <array>
#include <complex>
#include <valarray>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <chrono>
#include <random>
#include <numeric>
using namespace std;
#define int long long
typedef long long ll;
typedef unsigned long long ull;
//typedef unsigned __int128 HASH;
typedef pair<int,int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll,int> plli;
typedef pair<double, int> pdbi;
typedef pair<int,pii> pipii;
typedef pair<ll,pll> plpll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vector<int>> mat;
#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n);i>0;i--)
#define rrep2(i,a,b) for (int i=(a);i>b;i--)
#define pb push_back
#define fi first
#define se second
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
const ll hmod1 = 999999937;
const ll hmod2 = 1000000000 + 9;
const int INF = 1<<30;
const ll INFLL = 1LL<<62;
const double EPS = 1e-12;
const ll mod = 1000000000 + 7;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy8[8] = {0, 1, -1, 1, -1, 0, 1, -1};
const double pi = 3.141592653589793;
#define addm(X, Y) (X) = ((X) + ((Y) % mod) + mod) % mod
#define inside(y, x, h, w) (0 <= (y) && (y) < (h) && 0 <= (x) && (x) < (w)) ? true : false
//debug
#define DEBUG
#define DUMPOUT cout
#ifdef DEBUG
#define dump(...) DUMPOUT<<#__VA_ARGS__<<" :["<<__FUNCTION__<<":"<<__LINE__<<"]"<<endl; DUMPOUT<<" "; dump_func(__VA_ARGS__)
#else
#define dump(...)
#endif
void dump_func() {DUMPOUT << endl;};
template <class Head, class... Tail> void dump_func(Head&& head, Tail&&... tail) {
DUMPOUT << head;
if (sizeof...(Tail) == 0) DUMPOUT << " ";
else DUMPOUT << ", ";
dump_func(std::move(tail)...);
}
//ostream
template<typename T> ostream& operator << (ostream& os, vector<T>& vec) {
os << "["; for (int i = 0; i<vec.size(); i++) os << vec[i] << (i + 1 == vec.size() ? "" : ", "); os << "]";
return os;
}
template<typename T, typename U> ostream& operator << (ostream& os, pair<T, U>& pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
template<typename T, typename U> ostream& operator << (ostream& os, map<T, U>& map_var) {
os << "[";
for (auto itr = map_var.begin(); itr != map_var.end(); itr++) {
os << "(" << itr->first << ", " << itr->second << ")"; itr++; if(itr != map_var.end()) os << ", "; itr--;
}
os << "]";
return os;
}
template<typename T> ostream& operator << (ostream& os, set<T>& set_var) {
os << "[";
for (auto itr = set_var.begin(); itr != set_var.end(); itr++) {
os << *itr; ++itr; if(itr != set_var.end()) os << ", "; itr--;
}
os << "]";
return os;
}
int n;
int q[100000 + 5];
int dp[100000 + 5];
bool prime[100000 + 5];
bool isPrime(ll x) {
if (x == 2) return true;
else if (x < 2 || x % 2 == 0) return false;
else {
for (int i = 3; i * i <= x; i += 2) {
if (x % i == 0) return false;
}
}
return true;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
rep(i, n) {
cin >> q[i];
prime[i] = isPrime(q[i]);
}
q[n] = INFLL;
dp[0] = 1;
rep(i, n) {
if (prime[i]) {
if (i == n - 1) {
addm(dp[i + 1], dp[i]);
}
else {
if (prime[i + 1]) {
if (q[i] < q[i + 1]) {
addm(dp[i + 1], dp[i]);
if (q[i] < q[i + 2]) {
addm(dp[i + 2], dp[i]);
}
}
else {
if (q[i] < q[i + 2]) {
addm(dp[i + 2], dp[i]);
}
}
}
else {
if (q[i] < q[i + 2]) {
addm(dp[i + 2], dp[i]);
}
}
}
}
}
cout << dp[n] << endl;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
#include <fstream>
#include <bitset>
#include <time.h>
#include <tuple>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;
#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = 1e12;
const ll MOD = 1e9 + 7;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define rep(i,N) for(int i=0;i<(N);i++)
#define ALL(s) (s).begin(),(s).end()
#define EQ(a,b) (abs((a)-(b))<EPS)
#define EQV(a,b) ( EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()) )
#define fi first
#define se second
#define N_SIZE (1LL << 20)
#define NIL -1
ll sq(ll num) { return num*num; }
ll mod_pow(ll x, ll n) {
if (n == 0)return 1;
if (n == 1)return x%MOD;
ll res = sq(mod_pow(x, n / 2));
res %= MOD;
if (n % 2 == 1) {
res *= x;
res %= MOD;
}
return res;
}
ll mod_add(ll a, ll b) { return (a + b) % MOD; }
ll mod_sub(ll a, ll b) { return (a - b + MOD) % MOD; }
ll mod_mul(ll a, ll b) { return a*b % MOD; }
ll n;
ll a[100100];
ll dp[2][1001000];
map<ll, ll> id;
bool used[1001000];
vector<int> prime;
bool is_prime[1001000];
int sieve(int n) {//n以下の素数の数を返す
int p = 0;
for (int i = 0; i <= n; i++)is_prime[i] = 1;
is_prime[0] = is_prime[1] = 0;
for (int i = 2; i <= n; i++) {
if (is_prime[i]) {
prime.push_back(i);
id[i] = prime.size() - 1;
for (int j = 2 * i; j <= n; j += i)is_prime[j] = 0;
}
}
return p;
}
int main() {
sieve(1001000);
cin >> n;
rep(i, n)cin >> a[i];
if (!is_prime[a[0]])cout << 0 << endl;
else {
dp[0][0] = 1;
FOR(i, 1, n) {
if (is_prime[a[i]]) {
if (i > 1 && a[i] > a[i - 2])dp[0][i] = (dp[0][i] + dp[1][i - 1]) % MOD;
if (a[i] > a[i - 1])dp[0][i] = (dp[0][i] + dp[0][i - 1]) % MOD;
if (is_prime[a[i - 1]])dp[1][i] = (dp[1][i] + dp[0][i - 1]) % MOD;
}
else {
if (is_prime[a[i - 1]])dp[1][i] = (dp[1][i] + dp[0][i - 1]) % MOD;
}
}
cout << mod_add(dp[0][n - 1], dp[1][n - 1]) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void eratosthenes(int N, int* arr){
for(int i=0; i < N; i++){
arr[i] = 1;
}
for(int i=2; i < sqrt(N); i++){
if(arr[i]){
for(int j=0; i * (j + 2) < N; j++){
arr[i*(j+2)] = 0;
}
}
}
}
int main(void){
const int NMAX = 100002;
const int QMAX = 1000001;
const int MOD = 1e9+7;
int dp[NMAX][2]; // dp[idx][自分が素因数(0)か肩(1)か]
int isprime[QMAX];
for(int i = 0; i < NMAX; i++) for(int j = 0; j < 2; j++) dp[i][j] = 0;
eratosthenes(QMAX, isprime);
int N; cin >> N;
vector<int> q(N);
for(int i = 0; i < N; i++) cin >> q[i];
q.push_back(0);
if(isprime[q[0]])
dp[0][0] = 1;
for(int i = 0; i < N-1; i++){
for(int j = 0; j < 2; j++){
if(j == 0){
dp[i+1][1] = (dp[i+1][1] + dp[i][j]) % MOD;
if(q[i+1] > q[i] && isprime[q[i+1]]){
dp[i+1][0] = (dp[i+1][0] + dp[i][j]) % MOD;
}
}else{
if((i == 0 || q[i+1] > q[i-1]) && isprime[q[i+1]]){
dp[i+1][0] = (dp[i+1][0] + dp[i][j]) % MOD;
}
}
}
}
cout << (dp[N-1][0] + dp[N-1][1]) % MOD << endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a) (a).begin(),(a).end()
#define pb emplace_back
const ll MOD = (1e9+7);
#define MAX_NUM 1000000
bool era[MAX_NUM+1]={false};
void makeERA(){
for(int i=2;i<MAX_NUM;i++){
if(era[i]==true){
int x=MAX_NUM/i;
for(int j=2;j<=x;j++){
era[i*j]=false;
}
}
}
era[2]=true;
}
int main(){
for(int i=0;i<MAX_NUM;i++)era[i]=true;
era[0]=false;era[1]=false;
makeERA();
int n;
cin>>n;
vector<int> q(n);
rep(i,n)cin>>q[i];
static ll dp[100001][2];
rep(i,100001)rep(j,2)dp[i][j] = 0;
if(era[q[0]]){
dp[0][0] = 1;
dp[1][1] = 1;
}
for(int i=1;i<n;i++){
rep(j,2){
rep(l,2){
if( era[q[i-j]] == false )dp[i][j] = 0;
else{
if(i-1-j-l>=0 && q[i-j]>q[i-1-j-l]){
// cout<<i<<" "<<j<<" = "<<i-1-j<<" "<<l<<endl;
(dp[i][j] += dp[i-1-j][l])%=MOD;
}
}
}
}
}
cout<<(dp[n-1][0] + dp[n-1][1])%MOD<<endl;
}
|
#include<bits/stdc++.h>
#define int long long
using namespace std;
bool prime[1000009];
void era(){
prime[0]=1;
prime[1]=1;
for(int i=2;i<1000009;i++){
if(!prime[i]){
for(int j=i+i;j<1000009;j+=i) prime[j]=1;
}
}
}
int dp[100009][2];
signed main(){
era();
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)scanf("%ld",&a[i]);
if(!prime[a[0]]){
dp[0][0]=1;
dp[0][1]=1;
}
for(int i=0;i<n;i++){
// 1
if( i+1<n && a[i]<a[i+1] &&!prime[a[i+1]] )dp[i+1][0] += dp[i][0];
if( i+2<n && a[i]<a[i+1] &&!prime[a[i+1]] )dp[i+1][1] += dp[i][0];
// 2
if( i+2<n && a[i]<a[i+2] &&!prime[a[i+2]] )dp[i+2][0] += dp[i][1];
if( i+3<n && a[i]<a[i+2] &&!prime[a[i+2]] )dp[i+2][1] += dp[i][1];
dp[i+1][0]%=1000000007;
dp[i+1][1]%=1000000007;
dp[i+2][0]%=1000000007;
dp[i+2][1]%=1000000007;
}
cout<<(dp[n-1][0]+dp[n-2][1])%1000000007<<endl;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.