algoritmo combinatorial recursivo

24/03/2017

0

Saudações,
Preciso converter um algoritmo iterativo com parâmetros estáticos em um combiantorial com parâmetro dinâmico.
O exemplo é esse:

    public class UmParDeInteiros{
        public int de;
        public int ate;

        public UmParDeInteiros(int i, int j){
            this.de = i;
            this.ate = j;
        }
    }
    
    //em main()
    ArrayList<UmParDeInteiros> UmArrayDeParDeInteiros;

    //combinação a 3 em algoritmo iterativo parametros estaticos
    for(int s1de=0; s1de<2; s1de++){//entrada
        for(int s1ate=4; s1ate<7; s1ate++){//internos
            UmArrayDeParDeInteiros.add(new UmParDeInteiros(s1de,s1ate));
            for(int s2de=0; s2de<2; s2de++){//entrada
                for(int s2ate=4; s2ate<7; s2ate++){//internos
                    UmArrayDeParDeInteiros.add(new UmParDeInteiros(s2de,s2ate));
                    for(int s3de=0; s3de<2; s3de++){//entrada
                        for(int s3ate=4; s3ate<7; s3ate++){//internos
                            UmArrayDeParDeInteiros.add(new UmParDeInteiros(s3de,s3ate));
                            for(UmParDeInteiros s:UmArrayDeParDeInteiros){
                                System.out.print("("+s.de+","+s.ate+")");
                            }
                            System.out.println();
                            UmArrayDeParDeInteiros.remove(UmArrayDeParDeInteiros.size()-1);
                        }
                    }
                    UmArrayDeParDeInteiros.remove(UmArrayDeParDeInteiros.size()-1);
                }
            }
            CombLayerDeEntrada.remove(UmArrayDeParDeInteiros.size()-1);
        }
    }


/*SAIDA
(0,4)(0,4)(0,4)
(0,4)(0,4)(0,5)
(0,4)(0,4)(0,6)
(0,4)(0,4)(1,4)
(0,4)(0,4)(1,5)
(0,4)(0,4)(1,6)
(0,4)(0,5)(0,4)
(0,4)(0,5)(0,5)
(0,4)(0,5)(0,6)
.......
*/

   
    //combinação a 2 em algoritmo iterativo parametros estaticos
    for(int s1de=0; s1de<2; s1de++){//entrada
        for(int s1ate=4; s1ate<7; s1ate++){//internos
            UmArrayDeParDeInteiros.add(new UmParDeInteiros(s1de,s1ate));
            for(int s2de=0; s2de<2; s2de++){//entrada
                for(int s2ate=4; s2ate<4; s2ate++){//internos
                    UmArrayDeParDeInteiros.add(new UmParDeInteiros(s2de,s2ate));
                    for(UmParDeInteiros s:UmArrayDeParDeInteiros){
                        System.out.print("("+s.de+","+s.ate+")");
                    }
                    System.out.println();
                    UmArrayDeParDeInteiros.remove(UmArrayDeParDeInteiros.size()-1);
                }
            }
            CombLayerDeEntrada.remove(UmArrayDeParDeInteiros.size()-1);
        }
    }


Estou tentando fazer um algoritmo recursivo com parametros pra este problema,
porque a solução combinatorial parece que é mais natural pra recursividade, a entrada pode variar,
por exemplo, combinação de 5 3 a 3, combinacao de 10 8 a 8, etc
porem não obtive sucesso ate agora. Alguém, pode ajudar com uma solução? Pode ser em c, c++ ou
qualquer linguagem parecida.
Obrigado.
Aquiles Braganca

Aquiles Braganca

Responder

Que tal ter acesso a um e-book gratuito que vai te ajudar muito nesse momento decisivo?

Ver ebook

Recomendado pra quem ainda não iniciou o estudos.

Eu quero
Ver ebook

Recomendado para quem está passando por dificuldades nessa etapa inicial

Eu quero

Utilizamos cookies para fornecer uma melhor experiência para nossos usuários, consulte nossa política de privacidade.

Aceitar