static void bouncy_nightrider_generate_moves_recursive(square step_departure)
{
vec_index_type k;
if (!NoEdge(step_departure))
settraversed(step_departure);
for (k= vec_knight_start; k<=vec_knight_end; k++)
{
curr_generation->arrival = step_departure+vec[k];
while (is_square_empty(curr_generation->arrival))
{
push_move();
if (!NoEdge(curr_generation->arrival) && !traversed(curr_generation->arrival))
{
bouncy_nightrider_generate_moves_recursive(curr_generation->arrival);
break;
}
else
curr_generation->arrival += vec[k];
}
if (piece_belongs_to_opponent(curr_generation->arrival))
push_move();
}
}
static boolean rrefnech(square i1, validator_id evaluate)
{
square const sq_target = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
vec_index_type k;
if (!NoEdge(i1))
settraversed(i1);
for (k= vec_knight_start; k<=vec_knight_end; k++) {
square sq_departure = i1+vec[k];
while (is_square_empty(sq_departure))
{
if (!NoEdge(sq_departure) &&
!traversed(sq_departure)) {
if (rrefnech(sq_departure,evaluate))
return true;
break;
}
sq_departure += vec[k];
}
if (EVALUATE_OBSERVATION(evaluate,sq_departure,sq_target))
return true;
}
return false;
}
const Tuple<Nested<const int>,Nested<const int>>& SegmentSoup::polygons() const {
if (nodes() && !polygons_.x.size() && !polygons_.y.size()) {
const auto incident = incident_elements();
// Start from each segment, compute the contour that contains it and classify as either closed or open
vector<vector<int>> closed, open;
vector<bool> traversed(elements.size()); // Which segments have we covered already?
for (int seed : range(elements.size())) {
if (traversed[seed])
continue;
const int start = elements[seed].x;
vector<int> poly;
poly.push_back(start);
for (int node=start,segment=seed;;) {
traversed[segment] = true;
const int other = elements[segment][elements[segment].x==node?1:0];
if (other==start) { // Found a closed contour
closed.push_back(poly);
break;
}
if (incident[other].size()!=2) { // Found the end of a closed contour, or a nonmanifold vertex
// Traverse backwards to fill in the entire open contour
poly.clear();
poly.push_back(other);
for (int node2=other,segment2=segment;;) {
traversed[segment2] = true;
node2 = elements[segment2][elements[segment2].x==node2?1:0];
poly.push_back(node2);
if (incident[node2].size()!=2)
break;
segment2 = incident[node2][incident[node2][0]==segment2?1:0];
}
// If segments are oriented, preserve this order
reverse(poly.begin(),poly.end());
open.push_back(poly);
break;
}
// Node other is manifold, so continue to the next segment
node = other;
poly.push_back(node);
segment = incident[node][incident[node][0]==segment?1:0];
}
}
// Store results
polygons_ = tuple(Nested<const int>::copy(closed),Nested<const int>::copy(open));
}
return polygons_;
}
void resetColors(struct Node* x) {
if (x == NULL)
return;
if (traversed(x)) {
return;
}
add(&stack, x, NULL);
x->color = 0;
resetColors(x->next);
int i;
for (i = 0; i < x->nYields; i++) {
resetColors(x->yields[i]);
}
}
void Solution::solve(vector<vector<char> > &A) {
if (A.size() == 0) { return; }
vector<vector<bool> > traversed(A.size(), vector<bool>(A[0].size(), false));
int i, j;
// Traverse all the edges of the board
for (j = 0; j < A[0].size(); j++) {
if (A[0][j] == 'O') {
traverseGraph(A, 0, j, traversed);
}
}
for (j = 0; j < A[0].size(); j++) {
if (A[A.size()-1][j] == 'O') {
traverseGraph(A, A.size()-1, j, traversed);
}
}
for (i = 0; i < A.size(); i++) {
if (A[i][0] == 'O') {
traverseGraph(A, i, 0, traversed);
}
}
for (i = 0; i < A.size(); i++) {
if (A[i][A[0].size()-1] == 'O') {
traverseGraph(A, i, A[0].size()-1, traversed);
}
}
// Mark all the 'O's not visitied as X
for (i = 0; i < A.size(); i++) {
for (j = 0; j < A[0].size(); j++) {
if(A[i][j] == 'O' && !traversed[i][j]) {
A[i][j] = 'X';
}
}
}
}
