From 4675500a890f42f240e33f0f753681f11d0cba11 Mon Sep 17 00:00:00 2001
From: Karol Piotrowski <karpio7@st.amu.edu.pl>
Date: Sat, 6 Jun 2020 20:21:12 +0000
Subject: [PATCH] =?UTF-8?q?Prze=C5=9Blij=20pliki=20do=20''?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Main.cpp | 446 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 438 insertions(+), 8 deletions(-)

diff --git a/Main.cpp b/Main.cpp
index d6a794c..525c686 100644
--- a/Main.cpp
+++ b/Main.cpp
@@ -1,4 +1,6 @@
-#include<iostream>
+//Main drzewa decyzyjne 1 + algorytm genetyczny
+
+#include<iostream>
 #include<stdlib.h>
 #include<windows.h>
 #include<conio.h>
@@ -8,6 +10,12 @@
 #include<math.h>
 #include<stack>
 #include<fstream>
+#include <stdio.h>
+#include <cstdlib> 
+#include <ctime>
+#include<bits/stdc++.h>
+#include <algorithm>
+#include <utility>
 
 using namespace std;
 
@@ -15,7 +23,7 @@ const float maxFloat=FLT_MAX;
 const int ROW = 27;
 const int COL = 27;
 typedef pair<int, int> Pair;
-typedef pair<double, pair<int, int>> pPair;
+typedef pair<double, pair<int, int> > pPair;
 struct cell
 {
 	int parent_i, parent_j;
@@ -26,6 +34,361 @@ char pole[27][27][6];
 int pozycjaTraktoraX = 1, pozycjaTraktoraY = 1;
 char currentWay = 'S';
 
+
+//algorytm genetyczny
+int scoreBuraki = 0; 
+int scoreZiemniaki = 0; 
+int rozmiarPopulacji = 50;
+string * zebraneBuraki = new string[rozmiarPopulacji];
+string * zebraneZiemniaki = new string[rozmiarPopulacji];
+string * burakiDoSadzenia = new string[20];
+string * ziemniakiDoSadzenia = new string[20];
+int gmoLeftBuraki;
+int gmoLeftZiemniaki;
+string kod_genetyczny[27][27];
+
+string generateValue() {
+	
+	char trash[100];
+	string x = itoa(rand() % 1000,trash,10);
+	if (x.size() == 2) {
+		x = "0" + x;
+	}
+	else if (x.size() == 1) {
+		x = "00" + x;
+	}
+	
+	return x;
+	
+}
+
+
+string generateVegetable() {
+	
+	string taste = generateValue(); 
+	string colour = generateValue();
+	string size = generateValue();
+	
+	return taste + colour + size;
+	
+}
+
+
+void generatePopulation(string * population,int length) {
+	
+	int i;
+	for(i=0;i<length;i++) {
+		population[i] = generateVegetable();
+	}
+}
+
+
+int power(int x, int y) {
+	
+  if (y == 0) return 1;
+  if (y == 1) return x;
+  
+  int temp = power(x, y/2);
+  if (y%2 == 0) return temp * temp;
+  else return x * temp * temp;
+}
+
+
+int stringToInt(string str,int size) {
+	
+	int x = 0;
+	int i;
+	reverse(str.begin(),str.end());
+	
+	for(i=0;i<size;i++) {
+		x += (str[i] - '0') * power(10,i);
+	}
+	
+	reverse(str.begin(),str.end());
+	
+	return x;	
+}
+
+
+int fitness(string vegetable) {
+	
+	int taste = stringToInt(vegetable.substr(0,3),3);
+	int colour = stringToInt(vegetable.substr(3,3),3);
+	int size = stringToInt(vegetable.substr(6,3),3);
+	
+	return (taste+colour+size)/3;
+}
+
+
+bool comparePair(const pair<int, string>&i, const pair<int, string>&j)
+{
+   	return i.first > j.first;
+}
+
+    
+void ranking(string * population,string * parents, int populationSize, int parentsNumber) {
+	
+	int i;
+	pair <int,string> fitnessTable[populationSize];
+	for(i=0;i<populationSize;i++) { 
+		fitnessTable[i] =  make_pair(fitness(population[i]),population[i]);
+	}
+	
+	sort(fitnessTable,fitnessTable+populationSize,comparePair);
+	
+	for(i=0;i<parentsNumber;i++) {
+		parents[i] = fitnessTable[i].second;
+	}	
+}
+
+
+bool exists(int len, int * array, int element) {
+	
+	int i;
+	for(i=0;i<len;i++) {
+		if (array[i] == element) return true;
+	}
+	return false;
+}
+
+
+void selection(string * population,string * parents, int populationSize, int parentsNumber) {
+	
+	int i,j,k;
+	pair <int,string> fitnessTable[populationSize];
+	for(i=0;i<populationSize;i++) { 
+		fitnessTable[i] =  make_pair(fitness(population[i]),population[i]);
+	}
+	
+	sort(fitnessTable,fitnessTable+populationSize,comparePair);
+	
+	int roulette;
+	int taken[parentsNumber];
+	int sum = 0;
+	for(i=0;i<parentsNumber;i++) {
+		for(j = populationSize - 1;j>=0;j--) {
+			if(not exists(parentsNumber,taken,j)) {
+				sum += 	fitnessTable[j].first;
+				fitnessTable[j].first = sum;
+			}
+			
+		}
+		roulette = rand() % fitnessTable[0].first;
+		j = 0;
+		while(exists(parentsNumber,taken,j)) {
+			j += 1;
+		}
+		while(roulette > fitnessTable[j].first and j<populationSize) {
+			if(not exists(parentsNumber,taken,j)) {
+				roulette -= fitnessTable[j].first;
+			}
+			j+=1;
+		}
+		parents[i] = fitnessTable[j].second;
+		taken[i] = j;
+	}
+	
+	
+		
+}
+
+
+string mutate(string child) {
+	
+	int d3 = rand() % 3;
+	string mutation = generateValue();
+	switch(d3) {
+		case 0:
+			child = mutation + child.substr(3,6);
+			break;
+		case 1:
+			child = child.substr(0,3) + mutation + child.substr(6,3);
+			break;
+		case 2:
+			child = child.substr(0,6) + mutation;
+			break;
+	}
+	
+	return child;
+}
+
+
+string cross(string parent[2]) {
+	
+	int i;
+	string child = "";
+	for(i=0;i<3;i++) {
+		child += parent[rand() % 2].substr(i*3,3);
+	}
+	if (child == parent[0] or child == parent[1]) {
+		string other;
+		if (child == parent[0]) other = parent[1];
+		else other = parent[0];
+		int d3 = rand() % 3;
+		switch(d3) {
+			case 0:
+				child = other.substr((rand() % 3)*3,3) + child.substr(3,6);
+				break;
+			case 1:
+				child = child.substr(0,3) + other.substr((rand() % 3)*3,3) + child.substr(6,3);
+				break;
+			case 2:
+				child = child.substr(0,6) + other.substr((rand() % 3)*3,3);
+				break;
+		}
+	}
+	int d1000 = rand() % 1000;
+	if (rand() % 100 == 0) {
+		child = mutate(child);
+	}
+	return child;
+}
+
+
+void crossover(string * parents,string * nextGen,int parentsNumber,int nextGenSize) {
+	
+	int counter = 0;
+	int i,j;
+	for(i=0;i<parentsNumber;i++) {
+		if (counter >= nextGenSize) {
+			break;
+		}
+		else {
+			nextGen[counter] = parents[i];
+		counter +=1;
+		}
+	}
+	while(counter < nextGenSize) {
+		for(i=0;i<parentsNumber;i++) {
+			if (counter >= nextGenSize) {
+				break;
+			}
+			else {
+				for(j=i;j<parentsNumber;j++) {
+					if (counter >= nextGenSize) {
+					break;
+					}
+					else {
+						string couple[2];
+						couple[0] = parents[i];
+						couple[1] = parents[j];
+						nextGen[counter] = cross(couple);
+						counter += 1;
+					}
+				}
+			}
+		}
+	}
+}
+
+
+void genetic_algorithm(string * population, int populationSize, int parentsNumber,string * outcome, int outcomeSize) {
+	
+	int iteration,i;
+	for(iteration=0;iteration<5;iteration++) {
+		string * parents = new string[parentsNumber];
+		selection(population,parents,populationSize,parentsNumber);
+		
+		string * nextGen = new string[populationSize];
+		crossover(parents,nextGen,parentsNumber,populationSize);
+		
+		delete[] population;
+		
+		population = new string[populationSize];
+		for(i=0;i<populationSize;i++) {
+			population[i] = nextGen[i];
+		}
+		delete[] nextGen;
+	}
+	ranking(population,outcome,populationSize,outcomeSize);
+}
+
+
+string przypiszKod(string warzywa) {
+		if (warzywa=="buraki") {
+			if (gmoLeftBuraki > 0) {
+				string temp = burakiDoSadzenia[gmoLeftBuraki - 1];
+				gmoLeftBuraki -= 1; 
+				return temp;
+			}
+			else {
+				return generateVegetable();
+			}
+		} 
+		else {
+			if (gmoLeftZiemniaki > 0) {
+				string temp = ziemniakiDoSadzenia[gmoLeftZiemniaki - 1];
+				gmoLeftZiemniaki -= 1; 
+				return temp;
+			}
+			else {
+				return generateVegetable();
+			}
+		}
+}
+
+
+void przypiszKodGenetyczny(int i, int j, char plant) {
+		if (plant == 'B') {
+			kod_genetyczny[i][j] = przypiszKod("buraki");
+		}
+		else if (plant == 'Z') {
+			kod_genetyczny[i][j] = przypiszKod("ziemniaki");
+		}
+}
+
+
+void obslugaAlgorytmuGenetycznego() {
+	cout << "Zebrane buraki: " << scoreBuraki << endl;
+	cout << "Zebrane ziemniaki: " << scoreZiemniaki << endl;
+		if(scoreBuraki>=rozmiarPopulacji) {
+			scoreBuraki = 0;
+			delete[] burakiDoSadzenia;
+			string * burakiDoSadzenia = new string[20];
+			for(int i = 0;i<20;i++) {
+				burakiDoSadzenia[i] = "000000000";
+			}
+			genetic_algorithm(zebraneBuraki, rozmiarPopulacji, rozmiarPopulacji - 5, burakiDoSadzenia, 20);
+			gmoLeftBuraki = 20;
+			delete[] zebraneBuraki;
+			string * zebraneBuraki = new string[rozmiarPopulacji];
+			for(int i=0;i<20;i++) {
+				cout << burakiDoSadzenia[i] << endl;
+			}
+}
+		if(scoreZiemniaki>=rozmiarPopulacji) {
+			scoreZiemniaki = 0;
+			delete[] ziemniakiDoSadzenia;
+			string * ziemniakiDoSadzenia = new string[20];
+			for(int i = 0;i<20;i++) {
+				ziemniakiDoSadzenia[i] = "000000000";
+			}
+			genetic_algorithm(zebraneZiemniaki, rozmiarPopulacji, rozmiarPopulacji - 5, ziemniakiDoSadzenia, 20);
+			gmoLeftZiemniaki = 20;
+			delete[] zebraneZiemniaki;
+			string * zebraneZiemniaki = new string[rozmiarPopulacji];
+			for(int i=0;i<20;i++) {
+				cout << ziemniakiDoSadzenia[i] << endl;
+			}
+	}
+}
+
+
+void generujKody() {
+	for(int i=0;i<27;i++) {
+		for(int j=0;j<27;j++) {
+			if (pole[i][j][0] == 'B') {
+				kod_genetyczny[i][j] = przypiszKod("buraki"); 
+				}
+			else if (pole[i][j][0] == 'Z') {
+				kod_genetyczny[i][j] = przypiszKod("ziemniaki"); 
+				}
+		}
+	}
+}
+//---------------------------------------------------------------------
+
+
 void color(string foregroundColor, string backgroundColor)
 {
 	HANDLE hOut;
@@ -158,6 +521,9 @@ void updatePola()
 		cout << endl;
 		color("white", "black");
 	}
+	
+	obslugaAlgorytmuGenetycznego();
+	
 }
 
 void correctMovement(char wantedWay)
@@ -198,14 +564,26 @@ void correctMovement(char wantedWay)
 	}
 }
 void Move(char kierunek)
-{
+{	
 	switch (kierunek)
 	{
-		//góra-(w)
+		//gA3ra-(w)
 		case 'w':
 		{
 			if (pole[pozycjaTraktoraY - 1][pozycjaTraktoraX][0] != '#')
 			{
+				if (pole[pozycjaTraktoraY - 1][pozycjaTraktoraX][0] == 'B') {
+					zebraneBuraki[scoreBuraki] = kod_genetyczny[pozycjaTraktoraY - 1][pozycjaTraktoraX];
+					scoreBuraki+=1;
+					kod_genetyczny[pozycjaTraktoraY - 1][pozycjaTraktoraX] = "000000000";
+					}
+					
+				else if (pole[pozycjaTraktoraY - 1][pozycjaTraktoraX][0] == 'Z') {
+					zebraneZiemniaki[scoreZiemniaki] = kod_genetyczny[pozycjaTraktoraY - 1][pozycjaTraktoraX];
+					scoreZiemniaki+=1;
+					kod_genetyczny[pozycjaTraktoraY - 1][pozycjaTraktoraX] = "000000000";
+				}
+					
 				correctMovement('N');
 				pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = '.';
 				pozycjaTraktoraY--;
@@ -213,13 +591,26 @@ void Move(char kierunek)
 			}
 			updatePola();
 		}break;
-		//dół-(s)
+		//dA3A‚-(s)
 		case 's':
 		{
 			if (pole[pozycjaTraktoraY + 1][pozycjaTraktoraX][0] != '#')
 			{
+				if (pole[pozycjaTraktoraY +1][pozycjaTraktoraX][0] == 'B') {
+					zebraneBuraki[scoreBuraki] = kod_genetyczny[pozycjaTraktoraY + 1][pozycjaTraktoraX];
+					scoreBuraki+=1;
+					kod_genetyczny[pozycjaTraktoraY + 1][pozycjaTraktoraX] = "000000000";
+					}
+					
+				else if (pole[pozycjaTraktoraY +1][pozycjaTraktoraX][0] == 'Z') {
+					zebraneZiemniaki[scoreZiemniaki] = kod_genetyczny[pozycjaTraktoraY + 1][pozycjaTraktoraX];
+					scoreZiemniaki+=1;
+					kod_genetyczny[pozycjaTraktoraY + 1][pozycjaTraktoraX] = "000000000";
+				}
+				
+
 				correctMovement('S');
-				pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = '.';
+				pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = '.';	
 				pozycjaTraktoraY++;
 				pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = 'T';
 			}
@@ -230,6 +621,19 @@ void Move(char kierunek)
 		{
 			if (pole[pozycjaTraktoraY][pozycjaTraktoraX - 1][0] != '#')
 			{
+				if (pole[pozycjaTraktoraY][pozycjaTraktoraX - 1][0] == 'B') {
+					zebraneBuraki[scoreBuraki] = kod_genetyczny[pozycjaTraktoraY][pozycjaTraktoraX - 1];
+					scoreBuraki+=1;
+					kod_genetyczny[pozycjaTraktoraY][pozycjaTraktoraX - 1] = "000000000";
+					}
+					
+				else if (pole[pozycjaTraktoraY][pozycjaTraktoraX - 1][0] == 'Z') {
+					zebraneZiemniaki[scoreZiemniaki] = kod_genetyczny[pozycjaTraktoraY][pozycjaTraktoraX - 1];
+					scoreZiemniaki+=1;
+					kod_genetyczny[pozycjaTraktoraY][pozycjaTraktoraX - 1] = "000000000";
+				}
+					
+					
 				correctMovement('W');
 				pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = '.';
 				pozycjaTraktoraX--;
@@ -242,16 +646,30 @@ void Move(char kierunek)
 		{
 			if (pole[pozycjaTraktoraY][pozycjaTraktoraX + 1][0] != '#')
 			{
+				if (pole[pozycjaTraktoraY][pozycjaTraktoraX + 1][0] == 'B') {
+					zebraneBuraki[scoreBuraki] = kod_genetyczny[pozycjaTraktoraY][pozycjaTraktoraX + 1];
+					scoreBuraki+=1;
+					kod_genetyczny[pozycjaTraktoraY ][pozycjaTraktoraX + 1] = "000000000";
+					}
+					
+				else if (pole[pozycjaTraktoraY][pozycjaTraktoraX + 1][0] == 'Z') {
+					zebraneZiemniaki[scoreZiemniaki] = kod_genetyczny[pozycjaTraktoraY][pozycjaTraktoraX + 1];
+					scoreZiemniaki+=1;
+					kod_genetyczny[pozycjaTraktoraY ][pozycjaTraktoraX + 1] = "000000000";
+				}
+					
 				correctMovement('E');
-				pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = '.';
+				pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = '.';	
 				pozycjaTraktoraX++;
 				pole[pozycjaTraktoraY][pozycjaTraktoraX][0] = 'T';
 			}
 			updatePola();
 		}break;
 	}
+	
 }
 
+
 bool isValid(int x, int y)
 {
 	if (pole[x][y][0] != '#')
@@ -500,6 +918,7 @@ void gogo(int endX,int endY)
 	Pair src = make_pair(pozycjaTraktoraX, pozycjaTraktoraY);
 	Pair dest = make_pair(endX, endY);
 	aStarSearch(grid, src, dest);
+	
 }
 
 void test1()
@@ -596,6 +1015,9 @@ void reciveState()
 				gogo(j+1 , i );
 			}
 			pole[i][j][0] = plant;
+			
+			przypiszKodGenetyczny(i,j,plant);		
+
 			if (plant == '.')
 			{
 				pole[i][j][1] = '1';
@@ -631,6 +1053,9 @@ void start1()
 	pole[goalY][goalX][0] = 'Z';
 	pole[goalY][goalX][1] = '9';
 	updatePola();
+	
+	generujKody();
+	
 	//sendState();		//trzeba ręcznie zmieniać między wysyłaniem stanu a pobieraniem stanu pola
 	reciveState();
 }
@@ -657,6 +1082,8 @@ void start3()
 
 int main()
 {
+	srand(time(0));
+	
 	SetWindow(50, 30);
 	//create pola//
 	for (int i = 0; i < 27; i++)
@@ -705,8 +1132,11 @@ int main()
 		{
 			traktorDziala = false;
 		}
+		
+
 	} while (traktorDziala);
 	//---------end---------//
 
 	return 0;
-}
\ No newline at end of file
+}
+