static std::vector<Vec2d> make_one_period(double width, double scaleFactor, double z_cos, double z_sin, bool vertical, bool flip) { std::vector<Vec2d> points; double dx = M_PI_4; // very coarse spacing to begin with double limit = std::min(2*M_PI, width); for (double x = 0.; x < limit + EPSILON; x += dx) { // so the last point is there too x = std::min(x, limit); points.emplace_back(Vec2d(x,f(x, z_sin,z_cos, vertical, flip))); } // now we will check all internal points and in case some are too far from the line connecting its neighbours, // we will add one more point on each side: const double tolerance = .1; for (unsigned int i=1;i<points.size()-1;++i) { auto& lp = points[i-1]; // left point auto& tp = points[i]; // this point Vec2d lrv = tp - lp; auto& rp = points[i+1]; // right point // calculate distance of the point to the line: double dist_mm = unscale<double>(scaleFactor) * std::abs(cross2(rp, lp) - cross2(rp - lp, tp)) / lrv.norm(); if (dist_mm > tolerance) { // if the difference from straight line is more than this double x = 0.5f * (points[i-1](0) + points[i](0)); points.emplace_back(Vec2d(x, f(x, z_sin, z_cos, vertical, flip))); x = 0.5f * (points[i+1](0) + points[i](0)); points.emplace_back(Vec2d(x, f(x, z_sin, z_cos, vertical, flip))); // we added the points to the end, but need them all in order std::sort(points.begin(), points.end(), [](const Vec2d &lhs, const Vec2d &rhs){ return lhs < rhs; }); // decrement i so we also check the first newly added point --i; } } return points; }
void main(void) { FILE *file; int i; int cases; file=fopen("input.txt", "r"); if(file==NULL) exit(1); fscanf(file, "%d", &cases); for(i=0; i<cases; i++) { int x1, y1, x2, y2; int a1, b1, a2, b2; fscanf(file, "%d %d %d %d", &x1, &y1, &x2, &y2); fscanf(file, "%d %d %d %d", &a1, &b1, &a2, &b2); if(cross(x1, y1, x2, y2, a1, b1, a2, b2)) printf("1\n"); else if(cross2(x1, y1, x2, y2, a1, b1, a2, b2)) printf("2\n"); else printf("0\n"); } fclose(file); }
int totalNQueens(int n) { vector<int> col(n, 0); vector<int> cross1(n*2-1, 0); vector<int> cross2(n*2-1, 0); res = 0; dfs(0, n, col, cross1, cross2); return res; }
bool GameState::isOnBorder(Vector2 point, Direction direction) const { Vector2 point2 = point.getNeighbor(direction); if(!isOnBorder_(point) || !isOnBorder_(point2)) return false; if(!(direction & 1)) return true; Vector2 cross1(point.x, point2.y); Vector2 cross2(point2.x, point.y); return isOnBorder_(cross1) && isOnBorder_(cross2); }
/* * return the minimum on the projective line * */ int lp_base_case(FLOAT halves[][2], /* halves --- half lines */ int m, /* m --- terminal marker */ FLOAT n_vec[2], /* n_vec --- numerator funciton */ FLOAT d_vec[2], /* d_vec --- denominator function */ FLOAT opt[2], /* opt --- optimum */ int next[], int prev[]) /* next, prev --- double linked list of indices */ { FLOAT cw_vec[2], ccw_vec[2]; #ifdef CHECK FLOAT d_cw; int i; #endif int status, degen; FLOAT ab; /* find the feasible region of the line */ status = wedge(halves,m,next,prev,cw_vec,ccw_vec,°en); if(status==INFEASIBLE) return(status); /* no non-trivial constraints one the plane: return the unconstrained ** optimum */ if(status==UNBOUNDED) { return(lp_no_constraints(1,n_vec,d_vec,opt)); } ab = ABS(cross2(n_vec,d_vec)); if(ab < 2*EPS*EPS) { if(dot2(n_vec,n_vec) < 2*EPS*EPS || dot2(d_vec,d_vec) > 2*EPS*EPS) { /* numerator is zero or numerator and denominator are linearly dependent */ opt[0] = cw_vec[0]; opt[1] = cw_vec[1]; status = AMBIGUOUS; } else { /* numerator is non-zero and denominator is zero ** minimize linear functional on circle */ if(!degen && cross2(cw_vec,n_vec) <= 0.0 && cross2(n_vec,ccw_vec) <= 0.0 ) { /* optimum is in interior of feasible region */ opt[0] = -n_vec[0]; opt[1] = -n_vec[1]; } else if(dot2(n_vec,cw_vec) > dot2(n_vec,ccw_vec) ) { /* optimum is at counter-clockwise boundary */ opt[0] = ccw_vec[0]; opt[1] = ccw_vec[1]; } else { /* optimum is at clockwise boundary */ opt[0] = cw_vec[0]; opt[1] = cw_vec[1]; } status = MINIMUM; } } else { /* niether numerator nor denominator is zero */ lp_min_lin_rat(degen,cw_vec,ccw_vec,n_vec,d_vec,opt); status = MINIMUM; } #ifdef CHECK for(i=0; i!=m; i=next[i]) { d_cw = dot2(opt,halves[i]); if(d_cw < -2*EPS) { printf("error at base level\n"); exit(1); } } #endif return(status); }
int wedge(FLOAT halves[][2], int m, int next[], int prev[], FLOAT cw_vec[], FLOAT ccw_vec[], int *degen) { int i; FLOAT d_cw, d_ccw; int offensive; *degen = 0; for(i=0;i!=m;i = next[i]) { if(!unit2(halves[i],ccw_vec,EPS)) { /* clock-wise */ cw_vec[0] = ccw_vec[1]; cw_vec[1] = -ccw_vec[0]; /* counter-clockwise */ ccw_vec[0] = -cw_vec[0]; ccw_vec[1] = -cw_vec[1]; break; } } if(i==m) return(UNBOUNDED); i = 0; while(i!=m) { offensive = 0; d_cw = dot2(cw_vec,halves[i]); d_ccw = dot2(ccw_vec,halves[i]); if(d_ccw >= 2*EPS) { if(d_cw <= -2*EPS) { cw_vec[0] = halves[i][1]; cw_vec[1] = -halves[i][0]; (void)unit2(cw_vec,cw_vec,EPS); offensive = 1; } } else if(d_cw >= 2*EPS) { if(d_ccw <= -2*EPS) { ccw_vec[0] = -halves[i][1]; ccw_vec[1] = halves[i][0]; (void)unit2(ccw_vec,ccw_vec,EPS); offensive = 1; } } else if(d_ccw <= -2*EPS && d_cw <= -2*EPS) { return(INFEASIBLE); } else if((d_cw <= -2*EPS) || (d_ccw <= -2*EPS) || (cross2(cw_vec,halves[i]) < 0.0)) { /* degenerate */ if(d_cw <= -2*EPS) { (void)unit2(ccw_vec,cw_vec,EPS); } else if(d_ccw <= -2*EPS) { (void)unit2(cw_vec,ccw_vec,EPS); } *degen = 1; offensive = 1; } /* place this offensive plane in second place */ if(offensive) i = move_to_front(i,next,prev); i = next[i]; if(*degen) break; } if(*degen) { while(i!=m) { d_cw = dot2(cw_vec,halves[i]); d_ccw = dot2(ccw_vec,halves[i]); if(d_cw < -2*EPS) { if(d_ccw < -2*EPS) { return(INFEASIBLE); } else { cw_vec[0] = ccw_vec[0]; cw_vec[1] = ccw_vec[1]; } } else if(d_ccw < -2*EPS) { ccw_vec[0] = cw_vec[0]; ccw_vec[1] = cw_vec[1]; } i = next[i]; } } return(MINIMUM); }
void lp_min_lin_rat(int degen, FLOAT cw_vec[2], FLOAT ccw_vec[2], FLOAT n_vec[2], FLOAT d_vec[2], FLOAT opt[2]) { FLOAT d_cw, d_ccw, n_cw, n_ccw; /* linear rational function case */ d_cw = dot2(cw_vec,d_vec); d_ccw = dot2(ccw_vec,d_vec); n_cw = dot2(cw_vec,n_vec); n_ccw = dot2(ccw_vec,n_vec); if(degen) { /* if degenerate simply compare values */ if(n_cw/d_cw < n_ccw/d_ccw) { opt[0] = cw_vec[0]; opt[1] = cw_vec[1]; } else { opt[0] = ccw_vec[0]; opt[1] = ccw_vec[1]; } /* check that the clock-wise and counter clockwise bounds are not near a poles */ } else if(not_zero(d_cw) && not_zero(d_ccw)) { /* the valid region does not contain a poles */ if(d_cw*d_ccw > 0.0) { /* find which end has the minimum value */ if(n_cw/d_cw < n_ccw/d_ccw) { opt[0] = cw_vec[0]; opt[1] = cw_vec[1]; } else { opt[0] = ccw_vec[0]; opt[1] = ccw_vec[1]; } } else { /* the valid region does contain a poles */ if(d_cw > 0.0) { opt[0] = -d_vec[1]; opt[1] = d_vec[0]; } else { opt[0] = d_vec[1]; opt[1] = -d_vec[0]; } } } else if(not_zero(d_cw)) { /* the counter clockwise bound is near a pole */ if(n_ccw*d_cw > 0.0) { /* counter clockwise bound is a positive pole */ opt[0] = cw_vec[0]; opt[1] = cw_vec[1]; } else { /* counter clockwise bound is a negative pole */ opt[0] = ccw_vec[0]; opt[1] = ccw_vec[1]; } } else if(not_zero(d_ccw)) { /* the clockwise bound is near a pole */ if(n_cw*d_ccw > 2*EPS) { /* clockwise bound is at a positive pole */ opt[0] = ccw_vec[0]; opt[1] = ccw_vec[1]; } else { /* clockwise bound is at a negative pole */ opt[0] = cw_vec[0]; opt[1] = cw_vec[1]; } } else { /* both bounds are near poles */ if(cross2(d_vec,n_vec) > 0.0) { opt[0] = cw_vec[0]; opt[1] = cw_vec[1]; } else { opt[0] = ccw_vec[0]; opt[1] = ccw_vec[1]; } } }