public static Leccion clonar(Leccion origen)
 {
     if (origen == null)
     {
         return(null);
     }
     return(new Leccion(origen.getAula(), origen.getBloque(), origen.getCurso()));
 }
예제 #2
0
 public bool validar_Campo(int hora, Leccion nueva)
 {
     if (this.aulas[hora, nueva.getAula()] != null || this.bloques[hora, nueva.getBloque()] != null || this.profesores[hora, this.encargados[nueva.getBloque()][nueva.getCurso()]] != null)
     {
         return(false);
     }
     return(true);
 }
        public Leccion popLeccion(int bloque, int hora)
        {
            Leccion valor = this.bloques[hora, bloque];

            if (valor != null)
            {
                this.bloques[hora, bloque]        = null;
                this.aulas[hora, valor.getAula()] = null;
                this.profesores[hora, this.getEncargado(valor)] = null;
                this.datocurso[bloque][valor.getCurso()][1]--;
            }
            return(valor);
        }
예제 #4
0
        public bool backTrackingRec(Horario horario, int bloque, List <List <Leccion> > pilaPorBloque)
        {
            comp++; if (bloque < Datos.listaCursos.Count)
            {
                mem += 4; for (int i = 0; i < pilaPorBloque[bloque].Count; i++)
                {
                    comp++; line++; asig++;
                    mem += 4; for (int j = 0; j < Datos.listaAulas.Count; j++)
                    {
                        comp++; line++; asig++;
                        mem += 4; for (int k = 0; k < 50; k++)
                        {
                            comp++; line++; asig++;
                            pilaPorBloque[bloque][i].setAula(j); asig++; line++;

                            comp++;  if (horario.setLeccion(k, bloque, pilaPorBloque[bloque][i], true))
                            {
                                comp += 8; asig += 3;
                                Leccion temp = pilaPorBloque[bloque][i]; asig++; line++; mem += 12;
                                pilaPorBloque[bloque].RemoveAt(i); line++;
                                comp += 2; asig++; if (backTrackingRec(horario, pilaPorBloque[bloque].Count == 0 ? bloque + 1 : bloque, pilaPorBloque))
                                {
                                    pilaPorBloque[bloque].Insert(i, temp); asig++; line++;
                                    return(true);
                                }
                                pilaPorBloque[bloque].Insert(i, temp); asig++; line++;
                                horario.popLeccion(bloque, k); line++; asig++;
                            }
                            else
                            {
                                podas++;
                            }
                        }
                    }
                }
                return(false);
            }
            else
            {
                Datos.horarioFinal = Datos.clonar(horario); asig++; line++; mem += pesoHorario;
                return(true);
            }
        }
예제 #5
0
        public void cambiar_Aula(int hora, int aula, int pareja)
        {
            Leccion objetivo = this.aulas[hora, aula];

            if (Datos.listaHorariosPadres[pareja].validar_Campo(hora, this.aulas[hora, this.aulas[hora, aula].getAula()]))
            {
                Leccion nuevo = Datos.listaHorariosPadres[pareja].cambiar(objetivo, hora);
                if (this.validar_Campo(hora, nuevo))
                {
                    this.aulas[hora, nuevo.getAula()]     = nuevo;
                    this.bloques[hora, nuevo.getBloque()] = nuevo;
                    this.profesores[hora, this.encargados[nuevo.getBloque()][nuevo.getCurso()]] = nuevo;
                }
                else
                {
                    Datos.listaHorariosPadres[pareja].cambiar(nuevo, hora);
                }
            }
        }
예제 #6
0
        public Leccion cambiar(Leccion nueva, int hora)
        {
            Leccion        retorno    = this.aulas[hora, nueva.getAula()];
            List <Leccion> contenedor = new List <Leccion>();
            int            t          = Datos.listaCursos[nueva.getBloque()][nueva.getCurso()].getLecciones();

            for (int i = 0; i < 50 || contenedor.Count < t; i++)
            {
                if (this.bloques[i, nueva.getBloque()].getCurso() == nueva.getCurso())
                {
                    contenedor.Add(this.bloques[i, nueva.getBloque()]);
                }
            }
            Leccion escogida = contenedor[Datos.randy.Next(0, contenedor.Count())];

            this.aulas[hora, escogida.getAula()]     = null;
            this.bloques[hora, escogida.getBloque()] = null;
            this.profesores[hora, this.encargados[escogida.getBloque()][escogida.getCurso()]] = null;
            this.aulas[hora, nueva.getAula()]     = nueva;
            this.bloques[hora, nueva.getBloque()] = nueva;
            this.profesores[hora, this.encargados[nueva.getBloque()][nueva.getCurso()]] = nueva;
            return(retorno);
        }
        public bool insertarFuerte(int hora, int bloque, Leccion x, int inicio, int fin)
        {
            Leccion aux;
            int     auxh;

            if (x == null)
            {
                if (!validar_bloque(hora, bloque))
                {
                    aux  = getLeccion_bloque(hora, bloque);
                    auxh = getHoraDisponible(bloque, aux, inicio, fin);
                    popLeccion(bloque, hora);
                    if (auxh == -1)
                    {
                        return(false);
                    }
                    if (!setLeccion(auxh, bloque, aux, false))
                    {
                        return(false);
                    }
                }
            }
            else
            {
                if (!validar_Campo(hora, bloque, x))
                {
                    if (!Datos.listaProfesores[getEncargado(x)].horavalida(hora) || !Datos.listaAulas[x.getAula()].horavalida(hora))
                    {
                        return(false);
                    }
                    else
                    {
                        if (!validar_bloque(hora, bloque))
                        {
                            aux  = getLeccion_bloque(hora, bloque);
                            auxh = getHoraDisponible(bloque, aux, inicio, fin);
                            if (auxh == -1)
                            {
                                return(false);
                            }
                            popLeccion(bloque, hora);
                            if (!setLeccion(auxh, bloque, aux, false))
                            {
                            }
                        }

                        if (!validar_profesor(hora, x.getBloque(), x.getCurso()))
                        {
                            aux  = getLeccion_bloque(hora, getLeccion_profesor(hora, getEncargado(x)).getBloque());
                            auxh = getHoraDisponible(aux.getBloque(), aux, inicio, fin);
                            if (auxh == -1)
                            {
                                return(false);
                            }
                            popLeccion(aux.getBloque(), hora);
                            if (!setLeccion(auxh, aux.getBloque(), aux, false))
                            {
                            }
                        }

                        if (!validar_aula(hora, x.getAula()))
                        {
                            aux  = getLeccion_bloque(hora, getLeccion_aula(hora, x.getAula()).getBloque());
                            auxh = getHoraDisponible(aux.getBloque(), aux, inicio, fin);
                            if (auxh == -1)
                            {
                                return(false);
                            }
                            popLeccion(aux.getBloque(), hora);
                            if (!setLeccion(auxh, aux.getBloque(), aux, false))
                            {
                            }
                        }
                        if (!setLeccion(hora, bloque, x, false))
                        {
                            return(false);
                        }
                    }
                }
                else
                {
                    setLeccion(hora, bloque, x, false);
                }
            }
            return(true);
        }
 public static bool cursoEqual(Leccion x, Leccion y)
 {
     return(!(x == null && y != null) &&
            !(x != null && y == null) &&
            ((x == null && y == null) || (x.getCurso() == y.getCurso())));
 }
        public static List <Horario> crucePMX(int padre, int madre, bool multiBloque)
        {
            PMX.camada = new List <Horario>();
            camada.Add(Datos.clonar(Datos.listaHorariosPadres[padre]));
            camada.Add(Datos.clonar(Datos.listaHorariosPadres[madre]));
            int[] intervalo = new int[2];
            int   repeticiones;

            if (multiBloque)
            {
                repeticiones = Datos.randy.Next(Datos.listaCursos.Count > 1?2:0, Datos.listaCursos.Count);
            }
            else
            {
                repeticiones = 1;
            }
            for (int r = 0; r < repeticiones; r++)
            {
                int          bloque = Datos.randy.Next(0, Datos.listaCursos.Count);
                List <int[]> mapeo  = new List <int[]>();
                Leccion      aux;
                intervalo[0] = Datos.randy.Next(0, 30);
                intervalo[1] = Datos.randy.Next(intervalo[0], intervalo[0] + 20);
                //for (int i = intervalo[0]; i <= intervalo[1]; i++)
                //{
                //    for (int j = 0; j < 2; j++)
                //    {
                //        int x = camada[j].getEncargado(camada[(j + 1) % 2].getLeccion_bloque(i, bloque));
                //        if (x != -1 && !Datos.listaProfesores[x].horavalida(i))
                //        {
                //            fallos+=2;
                //            return new List<Horario>() { null, null };
                //        }
                //    }
                //}
                for (int i = intervalo[0]; i <= intervalo[1]; i++)
                {
                    aux = camada[0].popLeccion(bloque, i);
                    camada[0].insertarFuerte(i, bloque, camada[1].popLeccion(bloque, i), intervalo[0], intervalo[1]);
                    camada[1].insertarFuerte(i, bloque, aux, intervalo[0], intervalo[1]);

                    mapeo = insertarMapeo(mapeo, new int[2] {
                        camada[0].getLeccion_bloque(i, bloque) != null ? camada[0].getLeccion_bloque(i, bloque).getCurso() : -1,
                        camada[1].getLeccion_bloque(i, bloque) != null ? camada[1].getLeccion_bloque(i, bloque).getCurso() : -1
                    });
                }
                Leccion[,] pila = new Leccion[2, mapeo.Count];
                int[,] horas    = new int[mapeo.Count, 2];
                for (int h = 0; h < mapeo.Count; h++)
                {
                    for (int k = 0; k < 50; k++)
                    {
                        if (k == intervalo[0])
                        {
                            k = intervalo[1];
                        }
                        for (int m = 0; m < 2; m++)
                        {
                            if (mapeo[h][m] == -1)
                            {
                                if (camada[m].getLeccion_bloque(k, bloque) == null)
                                {
                                    pila[(m + 1) % 2, h] = null;
                                    horas[h, m]          = k;
                                }
                            }
                            else
                            {
                                if (pila[(m + 1) % 2, h] == null && camada[m].getLeccion_bloque(k, bloque) != null &&
                                    camada[m].getLeccion_bloque(k, bloque).getCurso() == mapeo[h][m])
                                {
                                    aux = camada[m].popLeccion(bloque, k);;
                                    pila[(m + 1) % 2, h] = aux;
                                    horas[h, m]          = k;
                                }
                            }
                        }
                    }
                }
                //mutacion
                for (int i = 0; i < 2; i++)
                {
                    int x = Datos.randy.Next(0, pila.GetLength(1) / 3 == 0 ? Datos.randy.Next(0, 2) : (pila.GetLength(1) / 3) + 1);
                    for (int j = 0; j < x; j++)
                    {
                        mutaciones++;
                        int a, b;
                        a          = Datos.randy.Next(0, pila.GetLength(1));
                        b          = Datos.randy.Next(0, pila.GetLength(1));
                        aux        = pila[i, a];
                        pila[i, a] = pila[i, b];
                        pila[i, b] = aux;
                    }
                }
                //mutacion
                for (int i = 0; i < pila.GetLength(1); i++)
                {
                    for (int j = 0; j < 2; j++)
                    {
                        camada[j].insertarFuerte(horas[i, j], bloque, pila[j, i], intervalo[0], intervalo[1]);
                    }
                }
            }

            for (int i = 0; i < 2; i++)
            {
                if (camada[i].apto() != null)
                {
                    camada[i] = null;
                }
            }
            if (camada[0] == null && camada[1] == null)
            {
                fallos++;
            }
            return(camada);
        }