¡Necesito de sus ayuda!

// Con esta clase pretendo contener los datos con los que trabajara el Algoritmo Genético (AG)
// Por ahora con puras claves, ya despues serian Objetos (Profesor, Horario, Materia o GrupoMateria)
// estos datos para el (AG) los obtendre asi:
// getListaClavesGruposMaterias()
// getListaClavesProfesores()
// getListaHorariosDisponibles()
// ...
public class AsignacionHorarios {

        /*
         * Por ahora esto no lo estoy usando, esto es los dias y las horas de dende se pueden programar o asignar los horarios
         * y además que me serviria para visualizar los horarios.  
        String[][] listaDias = {
                  { "1", "Lunes", },
                  { "2", "Martes", },
                  { "3", "Miercoles", },
                  { "4", "Jueves", },
                  { "5", "Viernes", },
        };     
        String[][] listaHoras = {
                          { "1", "4:00-5:00", },
                          { "2", "5:00-6:00", },
                          { "3", "6:00-7:00", },
                          { "4", "7:00-8:00", },
                          { "5", "8:00-9:00", },
                          { "6", "9:00-10:00", },
                };
        Curso[] cursos;
        Profesor[] profesores;*/
       
        // las claves de las horas y los dias posibles en que pueden ser asignados los horarios de los profesores y grupos de alumnos  
        static String[] clavesDias = { "1", "2", "3", "4", "5" };      
        static String[] clavesHoras = { "1", "2", "3", "4", "5", "6" };
       
        static int NUMEROHORASREQUERIDASMATERIA = 4;
        // grupos-materias de los que se asignaran sus respectivos profesores y horarios
        // La cadena esta constituida claveGrupoMateria = clave_materia + clave_grupo
        // Ejemplo AC1ISC6A se obtiene a partir de AC1 + ISC6A
        public static String[] clavesGruposMaterias = {
                        "AC1ISC6A", "BD1ISC7A", "ED2ISC6A", "ELBISC3A", "GFCISC6A",     "IA1ISC8A",
                        "IA2ISC9A",     "INEISC6A",     "IS2ISC9A",     "IVOISC3A",     "MCPISC8A",     "ME1ISC9A",
                        "ME2ISC9A",     "PR2ISC3A",     "PS1ISC6A",     "PS2ISC7A",     "RD1ISC7A",     "RSDISC9A",
                        "SO1ISC6A",     "SO2ISC7A",
        };
        // claves de grupos de alumnos que asisten a un mismo numero de semestre y carrera (pueden haber mas de uno con un mismo numero de semestre y carrera)
        public static String[] clavesGrupos = { "ISC6A", "ISC7A", "ISC3A", "ISC8A", "ISC9A" };
        // Ejemplo "ISC6A" significa ISC:Ingenieria en Sistemas Computaciones, 6: Sexto semestre, A: grupo A
       
        public static String[] clavesProfesores = {"6", "23", "26", "29", "46", "67", "36", "68", "71", "20" };        
       
        // Ahora estoy utilizando este arreglo bidimensional que me indica el horario disponible de c/profesor {"clave_profesor", clave_hora-clave_dia,.....}
        public static String[][] clavesHorasClavesDiasDisponibles = {
                  { "6", "2-1", "2-2", "2-3", "2-3", "2-5", "6-1", "6-2", "6-3", "6-4", "6-5" },
                  { "23", "2-1", "2-2", "2-3", "2-4", "3-1", "3-2", "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", "5-1", "5-2", "5-3", "5-4", "6-1", "6-2", "6-3", "6-4", },                 
                  { "26", "2-1", "2-2", "2-3", "2-4", "2-5", "3-1", "3-2", "3-3", "3-4", "3-5" },
                  { "29", "1-1", "1-2", "1-3", "1-4", "2-1", "2-2",     "2-3", "2-4", "3-1", "3-2",     "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", "5-1", "5-2", "5-3", "5-4", "6-1", "6-2",     "6-3", "6-4" },
                  { "46", "1-1", "1-2", "1-3", "1-4", "2-1", "2-2",     "2-3", "2-4", "3-1", "3-2",     "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", "5-1", "5-2", "5-3", "5-4", "6-1", "6-2",     "6-3", "6-4" },
                  { "67", "1-1", "1-2", "1-3", "1-4", "2-1", "2-2",     "2-3", "2-4", "3-1", "3-2",     "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", "5-1", "5-2", "5-3", "5-4", "6-1", "6-2",     "6-3", "6-4" },
                  { "36", "2-1", "2-2", "2-3", "2-4", "3-1", "3-2",     "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", },
                  { "68", "2-1", "2-2", "2-3", "2-4", "3-1", "3-2",     "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", "5-1", "5-2", "5-3", "5-4", "6-1", "6-2",     "6-3", "6-4" },
                  { "71", "2-1", "2-2", "2-3", "2-4", "3-1", "3-2",     "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", "5-1", "5-2", "5-3", "5-4", "6-1", "6-2",     "6-3", "6-4" },
                  { "20", "2-1", "2-3", "2-5", "3-1", "3-3", "3-5", "4-1", "4-3", "4-5", "5-1", "5-3", "5-5" },
        };
       
        //
        public static String[][] clavesMateriasDeseanImpartir = {
                  { "6", "RD1", "SO1", "SO2" },
                  { "23", "IA1", "IA2", "IS1", "IS2", "ME1", "ME2" },            
                  { "26", "BD1", "PS1" },                
                  { "29", "GFC", "IVO", "ED2", "ME1", "ME2", "PS2" },
                  { "46", "BD1", "ED2", "RSD" },                 
                  { "67", "BD1", "ED2", "ME1", "ME2", "RD1", "SO1" },
                  { "36", "ELB", "LEM", "MCP", "ME1", "ME2", "PR2" },
                  { "68", "INE"},
                  { "71", "INE", "IS1", "IS2" },
                  { "20", "AC1", "LEM", "PS1", "PS2" }
        };     
       
        public AsignacionHorarios(){
               
               
        }
        /*
         * Por ahora no he comentado las demas clases para subirlas, aparte que ando haciendo unas modificaciones
        public static void main(String[] args) {
                // TODO Auto-generated method stub     
               
                Ag alg = new Ag(new AsignacionHorarios(), 50, 5, 0.8f, 0.5f);
                alg.crearPoblacionInicial();
                //alg.evolucionar();
                       
        }*/
       
}

// Gen.java
package algoritmo;

// Basicamente lo que hace es contener los valores de los recursos que se asignan

public class Gen implements Cloneable {
       
        private String[] valores;
       
        public Gen(int longitudValores){               
                this.valores = new String[longitudValores];
        }
       
        // Permite realizar una copia del Gen
        public Object clone() {
                Object clon = null;
                try{
                        clon = super.clone();                  
                }
                catch(CloneNotSupportedException e) {
                        System.err.println("Gen no cloneable");
                }
                for(int i = 0; i < valores.length; i++)
                        ((Gen)clon).setValor(i, new String(valores[i]));
                return clon;
        }
       
        public void setValor(int indice, String valor){
               
                this.valores[indice] = valor;
        }
       
        public String getValor(int indice) {
                return valores[indice];
        }
        // Permite extraer una parte de los valores (subarray) que contiene el Gen
        public String[] getValores(int indiceInicia, int indiceTermina) {
                String[] subarrayStrings = new String[indiceTermina - indiceInicia];
                for(int i = 0; i < subarrayStrings.length; i++)
                        subarrayStrings[i] = valores[indiceInicia + i];
                return subarrayStrings;
        }
       
        public String toString() {
                String cadena = "";
                for(int i = 0; i < valores.length - 1; i++)
                        cadena += valores[i] + "|";
                cadena += valores[valores.length - 1];
                return cadena;
        }
}

// Cromosoma.java
package algoritmo;

import java.util.ArrayList;

import problema.AsignacionHorarios;

// Esta clase representa a un Cromosoma que esta conformado por un conjunto de Genes.
// Lo que se puede hacer es cruzarse con otro Cromosoma para generar uno nuevo (que puede sufrir una mutación)  
// Por default no tiene establecido el valor de su fitness (aptitud)

public class Cromosoma implements Cloneable, Comparable<Cromosoma>{
       
       
        private float fitness;
        private Gen genes[];
       
        // Constructor que me permite crear un nuevo Cromosoma de manera aleatoria (por default)
        public Cromosoma(){
               
                // Lo que aqui hago es crear los genes del Cromosoma en base a cada uno de los datos de los grupos-materias
               
                genes = new Gen[AsignacionHorarios.clavesGruposMaterias.length];
                for(int i = 0; i < AsignacionHorarios.clavesGruposMaterias.length; i++)                                
                        setGen(crearNuevoGen(i), i);           
                fitness = 0; // Inicialmente no se conoce la aptitud (que tan buena solución es) del cromosoma
               
        }
       
        // Constructor que me permite crear un nuevo Cromosoma pasandole los genes de algún otro Cromosona
        public Cromosoma(Gen[] genes){
               
                fitness = 0;
                this.genes = genes;
        }
       
        // Para crear una copia del Cromosoma actual (desconocia que los objetos son manejados por referencia) 
        public Object clone(){
               
                Object clon = null;
               
                try{
                        clon = super.clone();
                }
                catch(CloneNotSupportedException e){
                        System.err.println("Cromosoma no cloneable");
                }                      
                ((Cromosoma)clon).setGenes(genes.clone());     
                return clon;           
        }
        /**
         * Método de cruza de genes a partir de 2 cromosomas (padres) para crear un nuevo Cromosoma (descendiente)
         * @param pareja
         * @param puntoUnoCruza
         * @param puntoDosCruza
         * @return
         * (REVISAR PUNTOS DE CRUZA, CUANDO SE HACE POR DOS PUNTOS VER COHERENCIA. APLICAR PROBABILIDAD DE CRUZA)
         */
        public Cromosoma cruzar(Cromosoma pareja, int puntoUnoCruza, int puntoDosCruza){
                Cromosoma descendiente;
                // Comprueba que los puntos de cruza no caigan en los extremos
                if(puntoUnoCruza > 0 && puntoUnoCruza < (this.getNumeroGenes() - 1) && puntoDosCruza > 0 && puntoDosCruza < (this.getNumeroGenes() - 1)) {
                        Gen[] genesMios = getGenes();
                        Gen[] genesPareja = pareja.getGenes();
                        Gen[] genesHijo = new Gen[pareja.getNumeroGenes()];            
                        int inicioCadena = 0, finCadena = pareja.getGenes().length;            
                        copiarGenes(genesHijo, genesMios, inicioCadena , puntoUnoCruza);               
                        copiarGenes(genesHijo, genesPareja, puntoUnoCruza, puntoDosCruza);             
                        copiarGenes(genesHijo, genesMios, puntoDosCruza, finCadena);
                        descendiente = new Cromosoma(genesHijo);
                        descendiente.mutar();
                        return descendiente;
                }
                // Un punto de cruza
                else if(puntoUnoCruza > 0 && puntoUnoCruza < (this.getNumeroGenes() - 1)) {
                        return cruzar(pareja, puntoUnoCruza);
                }
                else if(puntoDosCruza > 0 && puntoDosCruza < (this.getNumeroGenes() - 1)) {
                        return cruzar(pareja, puntoDosCruza);
                }
                // No se realiza la cruza por tanto se devuelve este Cromosoma
                return this;           
        }
       
       
        // Método de cruza de genes a partir de 2 cromosomas (padres) para crear un nuevo Cromosoma (descendiente).
        //  
        public Cromosoma cruzar(Cromosoma pareja, int puntoCruza){             
                if(aplicarOperador(Ag.probabilidadjeCruza)) {
                        // Comprobar que el punto de cruza no caiga en ninguno de los dos extremos del Cromosoma
                        if(puntoCruza > 0 && puntoCruza < (this.getNumeroGenes()- 1)) {
                                Cromosoma descendiente;
                                Gen[] genesMios = getGenes();
                                Gen[] genesPareja = pareja.getGenes();
                                Gen[] genesHijo = new Gen[pareja.getNumeroGenes()];    
                       
                                int inicioCadena = 0, finCadena = pareja.getGenes().length;
                       
                                copiarGenes(genesHijo, genesMios, inicioCadena , puntoCruza);          
                                copiarGenes(genesHijo, genesPareja, puntoCruza, finCadena);
                                descendiente = new Cromosoma(genesHijo);
                                descendiente.mutar();
                                return descendiente;
                        }
                }
                return this; // No se realiza la cruza, por tanto se devuelve este Cromosoma
        }
       
        public int getNumeroGenes(){           
                return genes.length;
        }      
               
        public Gen getGen(int indice) {
                return genes[indice];
        }
       
        // Obtiene un conjunto de genes que tienen contenido la subcadena que reciben como parametro  
        public  ArrayList<Gen> getGenes(String contieneSubstring) {
                ArrayList<Gen> listaGenes = new ArrayList<Gen>();              
               
                // Se comprueba antes de recorrer todos los genes sino ya fueron obtenidos sus datos de esta claveGrupo        
                for(int i = 0; i < this.getNumeroGenes(); i++) {                       
                        String cadenaAnalizar = this.getGen(i).toString();                     
                        if(cadenaAnalizar.contains(contieneSubstring)) {                       
                                listaGenes.add(this.getGen(i));
                                System.out.println("gen:" + this.getGen(i));
                        }
                }              
                return listaGenes;
        }

        public Gen[] getGenes(){               
                return genes;          
        }
       
        public float getFitness(){             
                return fitness;        
        }
       
        public void setGenes(Gen[] genes) {
                this.genes = genes;
        }

        public void setGen(Gen gen, int indice) {              
                genes[indice] = gen;
        }

        //Establecer
        public void setFitness(float fitness){         
                this.fitness = fitness;
        }
       
        public String toString() {
                String cadena = "";
                for(int i = 0; i < getNumeroGenes() - 1; i++)
                        cadena += genes[i].toString() + "||";
                cadena += genes[getNumeroGenes() - 1] + "||" + fitness;
                return cadena;
        }
       
        /**
         * Permite comparar un Cromosoma con otro en base al fitness (aptitud) obtenido.
         */
        public int compareTo(Cromosoma c) {
                return (fitness < c.getFitness() ? -1 : (fitness == c.getFitness() ? 0 : 1));          
        }
       
        ////#########  
        /*
         * Aqui hago mis asignaciones de datos:
         *              obtener la materia a hacerle asignaciones
         *              determinar el profesor que la impartira
         *              obtener el horario en que esta disponible
         *             
         *
         * Esta parte de código lo tenia en otra clase (Ag: que es una clase donde corre el algoritmo)
         * He tenido problemas como manejar los datos de entrada, ya que en varias partes los reutilizo (es por eso que los tengo como estaticos)
         */
        private Gen crearNuevoGen(int indiceGrupoMateria) {
               
                // Ejemplo gen = |MT1ISC1A|1|1-1|3-4|4-6|5-1| (MT1: clave de la materia) (1:clave del profesor) (1-1, 3-4... : hora de clase dado por la interseción de una clave de hora y una clave de dia)
               
                String claveGrupoMateria = AsignacionHorarios.clavesGruposMaterias[indiceGrupoMateria];
                String claveMateria = claveGrupoMateria.substring(0, 3);
                ArrayList<String> clavesProfesoresCandidatos = buscarProfesoresDeseanImpartir(claveMateria);
                String claveProfesorAsignado = clavesProfesoresCandidatos.get(Ag.numeroAleatorio(clavesProfesoresCandidatos.size()));  
                String[] horarioDisponibleProfesorAsignado = getHorarioDisponible(claveProfesorAsignado);
               
                // Se le resta 1 para generar un indice menor a la longitud del arreglo, pero luego se suma 1 al indice aleatorio
                // devuelto para acceder al valor deseado
                String horaClase1 = horarioDisponibleProfesorAsignado[Ag.numeroAleatorio(horarioDisponibleProfesorAsignado.length - 1 ) + 1 ];
                String horaClase2 = horarioDisponibleProfesorAsignado[Ag.numeroAleatorio(horarioDisponibleProfesorAsignado.length - 1 ) + 1 ];
                String horaClase3 = horarioDisponibleProfesorAsignado[Ag.numeroAleatorio(horarioDisponibleProfesorAsignado.length - 1 ) + 1 ];
                String horaClase4 = horarioDisponibleProfesorAsignado[Ag.numeroAleatorio(horarioDisponibleProfesorAsignado.length - 1 ) + 1 ];         
               
                // crear nuevo gen
                Gen nuevoGen = new Gen(6);
               
                nuevoGen.setValor(0, claveGrupoMateria);
                nuevoGen.setValor(1, claveProfesorAsignado);
                nuevoGen.setValor(2, horaClase1);
                nuevoGen.setValor(3, horaClase2);
                nuevoGen.setValor(4, horaClase3);
                nuevoGen.setValor(5, horaClase4);
                return nuevoGen;               
        }
       
        // Método para obtener los profesores para impartir determinada materia
        private static ArrayList<String> buscarProfesoresDeseanImpartir(String claveMateria) {
               
                ArrayList<String> clavesProfesoresDeseanImpartir = new ArrayList<String>();
               
                for(int i = 0; i < AsignacionHorarios.clavesMateriasDeseanImpartir.length; i++)
                        for(int j = 1; j < AsignacionHorarios.clavesMateriasDeseanImpartir[i].length; j++)                             
                                if(AsignacionHorarios.clavesMateriasDeseanImpartir[i][j].equals(claveMateria))
                                        clavesProfesoresDeseanImpartir.add(AsignacionHorarios.clavesMateriasDeseanImpartir[i][0]);                             
                               
                return clavesProfesoresDeseanImpartir;
        }
       
        private static String[] getHorarioDisponible(String claveProfesor) {
                               
                for(int k = 0; k < AsignacionHorarios.clavesHorasClavesDiasDisponibles.length; k++)
                                if(claveProfesor == AsignacionHorarios.clavesHorasClavesDiasDisponibles[k][0])
                                        return AsignacionHorarios.clavesHorasClavesDiasDisponibles[k];
                return null;
        }
////#########
       
    // Operador de mutación aún no implementado
        private void mutar() {
                if(aplicarOperador(Ag.probabilidadMutacion)) { }
                                       
        }
       
        // copio una parte de los genes de genesPadre a genesHijo  
        private void copiarGenes(Gen[] genesHijo, Gen[] genesPadre, int inicioSegmento , int finSegmento){             
                for(int p = inicioSegmento ; p < finSegmento ; p++)                    
                        genesHijo[p] = (Gen)genesPadre[p].clone();             
        }
       
        // Me indica si aplicar algun operador genético en base a la probabilidad recibida    
        private boolean aplicarOperador(float probabilidad) {
                if(Ag.numeroAleatorio() < probabilidad)
                        return true;
                return false;
        }      
}