void traverseGraph(const vector<vector<char> > &graph, int i, int j, vector<vector<bool> > &traversed) {
//cout<<"Traversing "<<i<<" "<<j<<endl;
traversed[i][j] = true;
if((getCharAt(graph,i-1,j) == 'O') && (!traversed[i-1][j])) {
traverseGraph(graph, i-1, j, traversed);
}
if((getCharAt(graph,i+1,j) == 'O') && (!traversed[i+1][j])) {
traverseGraph(graph, i+1, j, traversed);
}
if((getCharAt(graph,i,j-1) == 'O') && (!traversed[i][j-1])) {
traverseGraph(graph, i, j-1, traversed);
}
if((getCharAt(graph,i,j+1) == 'O') && (!traversed[i][j+1])) {
traverseGraph(graph, i, j+1, traversed);
}
}
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';
}
}
}
}
/*-------------------------------------------------------------------------------------------------
Traverse the entire graph reachable through forward edges from this node. Return the number
of nodes reached.
-------------------------------------------------------------------------------------------------*/
static uint32 traverseGraph(
grNode node)
{
grNode nextNode;
grEdge edge;
uint32 numNodes = 1;
grNodeSetVisited(node, true);
grForeachNodeOutEdge(node, edge) {
nextNode = grEdgeGetToNode(edge);
if(!grNodeVisited(nextNode)) {
numNodes += traverseGraph(nextNode);
}
} grEndNodeOutEdge;
Node* NFAGenerator::traverseGraph(Node* n,const int endNumber, int from){
if( visited.find(n->nodeNum) != visited.end() ){
return visited.at(n->nodeNum);//already found
}else{
// not found, new node, iterate on it's edges
//visited[n->nodeNum]= insert(contorPairing(n->nodeNum,from));
map<char,vector<Node*>> edges;
map<char,vector<Node*>>::iterator mapit = edges.begin();
vector<Node*>::iterator vecit;
vector<Node*>::iterator newVecit;
Node* newNode = new Node();
visited[n->nodeNum]=newNode;
for ( mapit = n->edges.begin(); mapit!=n->edges.end(); ++mapit){// iterate on map
vector<Node*> nodes;
vector<Node*> newNodes;
nodes = mapit->second;
vecit = nodes.begin();
newVecit = newNodes.begin();
for(int i = 0 ; i < nodes.size() ; i++){// iterate on vector
Node* temp = traverseGraph(nodes.at(i),endNumber, n->nodeNum);
if(temp != NULL){
newVecit = newNodes.insert(newVecit,temp);
}
}
edges[mapit->first]=newNodes;
}
newNode->state.accepted = n->state.accepted;
newNode->state.token = n->state.token;
newNode->edges = edges;
if(n->nodeNum == endNumber){
end = newNode;
}
//visited[n->nodeNum]=newNode;
return newNode;
}
}
Node* NFAGenerator::copyGraph(Node* n,const int endNumber, int from){
visited.clear();
return traverseGraph(n,endNumber,from);
}
int main(int argc, char **argv){
#ifndef TEST
// Minimum number of nodes required to create a graph is three:
//
// A
// / \
// B --- C
//
// and maximum is set to 18000 (about 1.5 GB of RAM allocated).
// Theoretically our graph algorithms can work with up to as many
// nodes we want, but we have restricted the present program to
// generate graphs up to 18k nodes due to memory limitations some
// computers may have.
const unsigned int minimum = 3, maximum = 18000;
unsigned int current, nodes, digits;
EDGE** mat;
srand(time(NULL));
if(argc == 1){
fprintf(stderr, "No number of nodes passed\n");
usage();
return 1;
}
digits = strlen(argv[1]);
for(current = 0; current < digits; current++){
if (!isdigit(argv[1][current])){
fprintf(stderr, "%s is not a valid number\n", argv[1]);
usage();
return 1;
}
}
nodes = strtol(argv[1], NULL, 10);
if((nodes < minimum) || (nodes > maximum)){
fprintf(stderr, "%d is not between the allowed limits\n", nodes);
usage();
return 1;
}
mat = Allocate(EDGE*, nodes);
for(current = 0; current < nodes; current++){
mat[current] = Allocate(EDGE, nodes);
}
// Create a random singed graph
createGraph(mat, nodes);
// and traverse it to check for its balance
traverseGraph(mat, nodes);
// Optionally run Graphviz but in any case don't run it while testing
#ifdef VIZ
vizGraph(mat, nodes);
#endif
for(current = 0; current < nodes; current++){
free(mat[current]);
}
free(mat);
return 0;
#endif
// Cannot be here
#ifdef TEST
return RunTests();
#endif
}
