Java 를 사용하여 유전 알고리즘을 구현하는 방법은 무엇입니까?

유전 알고리즘을 통해 미로를 걷다. 그림 1 과 그림 2 모두 미로에서 성공적으로 나왔지만 그림 1 의 경로는 그림 2 의 경로보다 훨씬 길고 복잡합니다. 유전 알고리즘은 얼마나 많은 가능성을 계산하고 가장 간단한 것을 연산 결과로 선택할 수 있다.

예제 그림 1:

예 그림 2:

구현 코드:

수입? Java.util.arraylist;

수입? Java.util.collections;

수입? Java.util.iterator;

수입? Java.util.linkedlist;

수입? Java.util.list;

수입? Java.util.random;

/* *

* 유전 알고리즘을 사용하여 미로를 걷다

*

* @ 작성자 Orisun

*

*/

공공? 반? 갈족

Int? 유전자 _ 길이 -응? //유전자 길이

Int? Chrom _ len? //염색체 길이

Int? 인구; -응? //인구 규모

두 배? 교차 비율 -응? //교차율

두 배? Muta _ ratio? //변화율

Int? Iter _ limit? //진화가 가장 많은 대수학

목록 & ltboolean[]& gt；; 개인; -응? //현대 인구의 염색체를 저장합니다.

미로 미로

Int? 폭; -응? //미로 선에는 몇 개의 사각형이 있습니까?

Int? 키; -응? //미로에는 몇 개의 선이 있습니까?

공공? 반? BI {

두 배? 피트니스

Boolean [] indv;

공공? BI (이중? F,? 부울 [] ind) {

적응성 = f；;

Indv = ind

}

공공? 두 배? GetFitness() {

반환? 피트니스

}

공공? 부울 [] getindv () {

반환? Indv

}

}

목록 & ltBI & gt 최고 _ 개인; -응? //각 세대 중 최고의 개인을 저장하십시오.

공공? 가 (미로)

This. 미로 = 미로; -응?

This.width = 미로 지도 [0]. 길이;

This.height = 미로. 지도. 길이;

Chrom_len =? 4? * (폭+높이);

Gene_len =? 2;

인구 =? 20;

Cross_ratio =? 0.83;

Muta_ratio =? 0.002;

Iter_limit =? 300;

개인 =? 새 것? Arraylist & lt boolean [] > (인구);

베스트 _ 개인 =? 새 것? Arraylist & ltbi & gt (ITER _ limit);

}

공공? Int? GetWidth() {

반환? 폭;

}

공공? 무효화? 셋 폭 (int? 폭) {

This.width = 폭;

}

공공? 두 배? GetCross_ratio() {

반환? 교차 비율

}

공공? 목록 & ltBI & gtgetBest_individual() {

반환? 최고 _ 개인

}

공공? 미로 getLabyrinth() {

반환? 미로;

}

공공? 무효화? 미로 설정 {

This. 미로 = 미로;

}

공공? 무효화? SetChrom_len(int? Chrom_len) {

This.chrom _ len = chrom _ len

}

공공? 무효화? SetPopulation(int? 인구) {

This.population = 인구;

}

공공? 무효화? SetCross_ratio(double? 교차 비율) {

This.cross_ratio = 교차 비율;

}

공공? 무효화? SetMuta_ratio(double? Muta_ratio) {

This.muta _ ratio = muta _ ratio

}

공공? 무효화? SetIter_limit(int? Iter_limit) {

This.iter _ limit = ITER _ limit

}

//커뮤니티 초기화

공공? 무효화? InitPopulation() {

임의 r =? 새 것? Random (system.currenttimemillis ());

뭐 때문에? (int? 나 =? 0; 나< 인구; I++) {

Int? Len = gene _ len * chrom _ len

부울 [] ind =? 새 것? Boolean [len];

뭐 때문에? (int? J =? 0; J & ltlenj++)

Ind [j] = r.next boolean ();

Personals.add (ind);

}

}

//교차

공공? 무효화? 크로스 (부울 [] arr1,? 부울 [] arr2) {

임의 r =? 새 것? Random (system.currenttimemillis ());

Int? 길이 = arr1.length;

Int? 슬라이스 =? 0;

뭐해? {

Slice = r.nextInt (길이);

}? 언제? (슬라이스 = =? 0);

만약? (슬라이스 & lt 길이/? 2) {

뭐 때문에? (int? 나 =? 0; 나< 슬라이스; I++) {

부울? Tmp = arr1[I];

Arr1[I] = arr2 [I];

Arr 2[I]= tmp；;

}

}? 그렇지 않으면요? {

뭐 때문에? (int? I = 슬라이스; 나< 길이; I++) {

부울? Tmp = arr1[I];

Arr1[I] = arr2 [I];

Arr 2[I]= tmp；;

}

}

}

//변경

공공? 무효화? 돌연변이 (부울 [] 개인) {

Int? 길이 = individual.length

임의 r =? 새 것? Random (system.currenttimemillis ());

개인 [r.nextint (길이)] =? 가짜;

}

//룰렛 방법 하위 멤버를 선택하여 현재 세대의 최대 적응 값을 반환합니다.

공공? 두 배? 선택 () {

부울 [] [] next _ generation =? 새 것? Boolean[population][]； []; -응? //차세대

Int? 길이 = gene _ len * chrom _ len

뭐 때문에? (int? 나 =? 0; 나< 인구; I++)

Next_generation[i] =? 새 것? 부울 [길이];

Double[] 누적 =? 새 것? 이중 [인구];

Int? Best_index =? 0;

두 배? Max _ fitness = getfitness (individuals.get (best _ index));

누적 [0] = max _ fitness;

뭐 때문에? (int? 나 =? 1; 나< 인구; I++) {

두 배? Fit = getfitness (personals.get (I));

누적 [i] = 누적? 1]+fit;

//당대 최고의 개인을 찾다

만약? (fit & gtmax_fitness) {

Best _ index = I；;

Max _ fitness = fit

}

}

임의 rand =? 새 것? Random (system.currenttimemillis ());

뭐 때문에? (int? 나 =? 0; 나< 인구; I++)

Next _ generation [I] = individuals.get (findbyhalf (누적,

Rand.nextDouble() * 누적 [인구-? 1]);

//당대 최고의 개인과 그 적응도를 best_individual 에 넣는다.

피비 =? 새 것? BI(max_fitness, individuals.get (best _ index));

//printpath (individuals.get (best _ index));

//system.out.println (max _ fitness);

Best _ individual.add (bi);

//차세대

뭐 때문에? (int? 나 =? 0; 나< 인구; I++)

Individuals.set(i, next _ generation [I]);

반환? Max _ fitness

}

//반검색

공공? Int? FindByHalf(double[] arr,? 두 배? 찾기) {

만약? (< 찾기? 0? || find ==? 0? | | 찾기 & gtarr[arr.length-? 1])

반환? -1;

Int? Min =? 0;

Int? Max = 배열 길이-? 1;

Int? 중간 = 최소;

뭐해? {

만약? (medium == (min+max)/? 2) 을 참조하십시오

깨뜨리다

보통 = (최소+최대)/? 2;

만약? (arr [medium] < 찾기)

최소 = 중간;

그렇지 않으면요? 만약? (arr[medium] > 찾기)

Max = 보통;

기타

반환? 중간;

}? 언제? (min< max);

반환? 맥스

}

//적합도 계산

공공? 두 배? Getfitness (부울 [] 개체) {

Int? 길이 = individual.length

//현재 위치를 기록하고 진입점은 (1, 0) 입니다.

Int? X =? 1;

Int? Y =? 0;

//염색체의 유전자 지침에 따라 앞으로 움직입니다.

뭐 때문에? (int? 나 =? 0; 나< 길이; I++) {

부울? B 1 = 개인 [I];

부울? B2 = 개인 [++I];

// 00 왼쪽으로 가세요.

만약? (b 1 ==? 가짜? & amp& ampb2 ==? False) {

만약? (x>? 0? & amp& amp 미로지도 [y][x-? 1] ==? 참) {

X-;

}

}

// 0 1 오른쪽으로 이동

그렇지 않으면요? 만약? (b 1 ==? 가짜? & amp& ampb2 ==? 참) {

만약? (x+? 1? & lt 폭 및 크기. & amplabyrinth.map[y][x+? 1] ==? 참) {

X++；+;

}

}

// 10 위로 올라가

그렇지 않으면요? 만약? (b 1 ==? 정말? & amp& ampb2 ==? False) {

만약? (y>? 0? & amp& amp 미로. 지도 [y-? 1][x] ==? 참) {

Y-;

}

}

// 1 1 아래로

그렇지 않으면요? 만약? (b 1 ==? 정말? & amp& ampb2 ==? 참) {

만약? (y+? 1? LT 키와 몸무게. & amp 미로. 지도 [y+? 1][x] ==? 참) {

Y++；+;

}

}

}

Int? N = math.abs (x-labyrinth.x _ end)+math.abs (y-labyrinth.y _ end)+? 1;

//? (n== 1) 인 경우

//? 인쇄 경로 (개인);

반환? 1.0? /n;

}

//유전 알고리즘 실행

공공? 부울? 실행 () {

//커뮤니티 초기화

Initpopulation ();

임의 rand =? 새 것? Random (system.currenttimemillis ());

부울? 성공 =? 가짜;

언제? (ITER _ limit-& gt；; -응? 0) {

//인구 질서를 어지럽히다

Collections.shuffle (개인);

뭐 때문에? (int? 나 =? 0; 나< 인구? 1; 나+=? 2) {

//교차

만약? (rand.nextdouble () < 교차 비율) {

Cross(individuals.get(i), individuals.get(i+? 1));

}

//변경

만약? (rand.nextdouble () < Muta_ratio) {

돌연변이 (individuals.get (I));

}

}

//인구 교체

만약? (선택 () = =? 1) {

성공 =? 진실;

깨뜨리다

}

}

반환? 성공;

}

//? 공용 정적 void main(String[] args) {

//? GA ga = 새로운 ga (8,8);

//? 만약 (! Ga.run()) {

//? System.out.println ("미로를 빠져나갈 길을 찾지 못했다." " );

//? } 그렇지 않으면 {

//? Intgen = ga.best _ individual.size ();

//? 부울 [] 개체 = ga.best _ individual.get (gen-1). Indv

//? System.out.println(ga.getPath (개인));

//? }

//? }

//염색체 인쇄 방법에 따라

공공? Stringgetpath (부울 [] individual) {

Int? 길이 = individual.length

Int? X =? 1;

Int? Y =? 0;

LinkedList & lt 문자열 & gtstack=new? LinkedList & lt 문자열> ();

뭐 때문에? (int? 나 =? 0; 나< 길이; I++) {

부울? B 1 = 개인 [I];

부울? B2 = 개인 [++I];

만약? (b 1 ==? 가짜? & amp& ampb2 ==? False) {

만약? (x>? 0? & amp& amp 미로지도 [y][x-? 1] ==? 참) {

X-;

만약 (! Stack.isempty () & & ampstack.peek () = = = "right")

Stack.poll ();

기타

Stack.push ("left");

}

}? 그렇지 않으면요? 만약? (b 1 ==? 가짜? & amp& ampb2 ==? 참) {

만약? (x+? 1? & lt 폭 및 크기. & amplabyrinth.map[y][x+? 1] ==? 참) {

X++；+;

만약 (! Stack.isempty () & & ampstack.peek () = = = "left")

Stack.poll ();

기타

Stack.push ("right");

}

}? 그렇지 않으면요? 만약? (b 1 ==? 정말? & amp& ampb2 ==? False) {

만약? (y>? 0? & amp& amp 미로. 지도 [y-? 1][x] ==? 참) {

Y-;

만약 (! Stack.isempty () & & ampstack.peek () = = = "down")

Stack.poll ();

기타

Stack.push ("up");

}

}? 그렇지 않으면요? 만약? (b 1 ==? 정말? & amp& ampb2 ==? 참) {

만약? (y+? 1? LT 키와 몸무게. & amp 미로. 지도 [y+? 1][x] ==? 참) {

Y++；+;

만약 (! Stack.isempty () & & ampstack.peek () = = = "up")

Stack.poll ();

기타

Stack.push ("다운");

}

}

}

StringBuilder sb=new? StringBuilder (길이/4) ：

반복자< 문자열 & gtiter = stack.descendingiterator ();

While(iter.hasNext ())

Sb.append (iter.next ());

반환? Sb.tostring ();

}

}