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];
}
}
}
