#include<iostream>

#include<vector>

#include<string>

#include<set>

#include<stack>

using namespace std;

struct trans {

int camino_desde;

int camino_hasta;

char transicion_simbolo;

};

class NFA {

public:

vector<int> camino;

vector<trans> transiciones;

int estado_final;

NFA() {

int contar_camino() {

return camino.size();
}

void camino(int no_camino) {

for(int i = 0; i < no_camino; i++) {

camino.push_back(i);

void asig_camino(int camino_desde, int camino_hasta, char transicion_simbolo) {

trans nueva_transicion;

nueva_transicion.camino_desde = camino_desde;

nueva_transicion.camino_hasta = camino_hasta;

nueva_transicion.transicion_simbolo = transicion_simbolo;

transiciones.push_back(nueva_transicion);

void estado_final(int fs) {

estado_final = fs;

int estado_final() {

return estado_final;

void mostrar() {
 trans nueva_transicion;

cout<<"\n";

for(int i = 0; i < transiciones.size(); i++) {

nueva_transicion = transiciones.at(i);

cout<<"q"<<nueva_transicion.camino_desde<<" -->
q"<<nueva_transicion.camino_hasta<<" : Symbol -
"<<nueva_transicion.transicion_simbolo<<endl;

cout<<"\nThe final state is q"<<estado_final()<<endl;

};

NFA concatenar(NFA a, NFA b) {

NFA resultado;

resultado.camino(a.contar_camino() + b.contar_camino());

int i;

trans nueva_transicion;

for(i = 0; i < a.transiciones.size(); i++) {

nueva_transicion = a.transiciones.at(i);

resultado.asig_camino(nueva_transicion.camino_desde,
nueva_transicion.camino_hasta, nueva_transicion.transicion_simbolo);

resultado.asig_camino(a.estado_final(), a.contar_camino(), '^');

for(i = 0; i < b.transiciones.size(); i++) {

nueva_transicion = b.transiciones.at(i);

resultado.asig_camino(nueva_transicion.camino_desde + a.contar_camino(),
nueva_transicion.camino_hasta + a.contar_camino(), nueva_transicion.transicion_simbolo);
 }

resultado.estado_final(a.contar_camino() + b.contar_camino() - 1);

return resultado;

NFA kleene(NFA a) {

NFA resultado;

int i;

trans nueva_transicion;

resultado.camino(a.contar_camino() + 2);

resultado.asig_camino(0, 1, '^');

for(i = 0; i < a.transiciones.size(); i++) {

nueva_transicion = a.transiciones.at(i);

resultado.asig_camino(nueva_transicion.camino_desde + 1,
nueva_transicion.camino_hasta + 1, nueva_transicion.transicion_simbolo);

resultado.asig_camino(a.contar_camino(), a.contar_camino() + 1, '^');

resultado.asig_camino(a.contar_camino(), 1, '^');

resultado.asig_camino(0, a.contar_camino() + 1, '^');

resultado.estado_final(a.contar_camino() + 1);

return resultado;

}
NFA seleccion(vector<NFA> selecciones, int num_selecciones) {

NFA resultado;

int camino_count = 2;

int i, j;

NFA med;

trans nueva_transicion;

for(i = 0; i < num_selecciones; i++) {

camino_count += selecciones.at(i).contar_camino();

resultado.camino(camino_count);

int adder_track = 1;

for(i = 0; i < num_selecciones; i++) {

resultado.asig_camino(0, adder_track, '^');

med = selecciones.at(i);

for(j = 0; j < med.transiciones.size(); j++) {

nueva_transicion = med.transiciones.at(j);

resultado.asig_camino(nueva_transicion.camino_desde + adder_track,
nueva_transicion.camino_hasta + adder_track, nueva_transicion.transicion_simbolo);

adder_track += med.contar_camino();

resultado.asig_camino(adder_track - 1, camino_count - 1, '^');

}
 resultado.estado_final(camino_count - 1);

return resultado;

NFA re_to_nfa(string re) {

stack<char> operators;

stack<NFA> operands;

char op_sym;

int op_count;

char cur_sym;

NFA *new_sym;

for(string::iterator it = re.begin(); it != re.end(); ++it) {