C++ Puzzle::GetValue方法代码示例

Puzzle PuzzleGenerator::SimulatedAnnealing_Linear(Puzzle p, double temp_start, double delta, double epsilon)
{
	// Function that uses simulated annealing algorithm to find best value puzzle.
	// TEMP_START = initial temperature
	// DELTA = amount that temperature decreases per iteration
	// returns the best puzzle found 

	Puzzle current = p;

	// Keep track of the time so we don't exceed it.
	Timer t;
	t.StartTimer();
	
	int i = 0; // iteration counter (for debugging)
	double temperature = temp_start;

	while (temperature > epsilon)
	{
		//printf ("\nSIMULATED ANNEALING ITERATION %i\n", i);


		// get random successor
		Puzzle successor = current.GetRandomSuccessor();
		//printf ("current value = %i\n", current.GetValue());
		//printf ("successor value = %i\n", successor.GetValue());
		//printf ("temperature = %f\n", temperature);

		// if successor is a "good" move accept it
		if (successor.GetValue() > current.GetValue())
		{
			//printf("successor value > current value...ACCEPTED!\n");
			current = successor;
		}
		else // otherwise accept the move with probability of e^(deltaE/temperature)
		{
			int deltaE = successor.GetValue() - current.GetValue(); // calculate delta E
			//printf("deltaE = %i\n", deltaE);
			double randVal = (rand() % 1000) / 1000.0; // generate random value between (0,1)
			//printf("randVal = %f\n", randVal);
			double thresh = exp(deltaE/temperature);
			//printf("thresh = %f\n", thresh);
			if (randVal < thresh)
			{
				//printf("successor value randomly ACCEPTED\n");
				current = successor;
			}
		}
		

		// cool temperature each iteration
		temperature -= delta;

		// increment iteration counter
		i++;

	}
	
	return current;
}

/** 
* 	Function that uses simulated annealing algorithm to find best value puzzle.
* 	TEMP_START = initial temperature
* 	ALPHA = how much the temperature is 'cooled' each iteration
* 	EPSILON = when temperature reaches the epsilon we're done
* 	returns the best puzzle found  
**/
Puzzle PuzzleGenerator::SimulatedAnnealing_Exp(Puzzle p, double temp_start, double alpha, double epsilon)
{

	Puzzle current = p;

	// Keep track of the time so we don't exceed it.
	Timer t;
	t.StartTimer();
	
	int i = 0; // iteration counter (for debugging)
	double temperature = temp_start;

	while (temperature > epsilon)
	{
		// get random successor
		Puzzle successor = current.GetRandomSuccessor();

		// if successor is a "good" move accept it
		if (successor.GetValue() > current.GetValue())
		{
			current = successor;
		}
		else // otherwise accept the move with probability of e^(deltaE/temperature)
		{
			int deltaE = successor.GetValue() - current.GetValue(); // calculate delta E
			double randVal = (rand() % 1000) / 1000.0; // generate random value between (0,1)
			double thresh = exp(deltaE/temperature);
			if (randVal < thresh)
			{
				//printf("successor value randomly ACCEPTED\n");
				current = successor;
			}
		}
		

		// cool temperature each iteration
		temperature *= alpha;

		// increment iteration counter
		i++;

	}
	
	return current;
}

Puzzle PuzzleGenerator::GeneratePuzzle()
{
	timer.StartTimer();
	maxtime = 58.0; // to make sure we don't exceed a minute

	// Declare variables for Simulated Annealing Algorithm
	double startingTemp;
	double alpha;
	double epsilon;

	// Determine if puzzle is "large" or not (so we can adjust how the algorithm performs)
	if (nRows*nColumns >= 80 || nRows*nColumns*(maxVal - minVal - 1) > 500)
	{
		startingTemp = 100;
		alpha = 0.9999;
		epsilon = 0.001;
	}
	else 
	{
		startingTemp = 100;
		alpha = 0.999;
		epsilon = 0.001;
	}


	Puzzle startingPuzzle(nRows, nColumns, minVal, maxVal);

	Puzzle bestPuzzle = SimulatedAnnealing_Exp(startingPuzzle, startingTemp, alpha, epsilon);
	int i = 0;

	while (timer.GetElapsedTime() < maxtime)
	{
		startingPuzzle = Puzzle(nRows, nColumns, minVal, maxVal);
		Puzzle p = SimulatedAnnealing_Exp(startingPuzzle, startingTemp, alpha, epsilon);
		if (p.GetValue() > bestPuzzle.GetValue())
		{
			bestPuzzle = p;
		}
		i++;
	}

	return bestPuzzle;

}

/** NOT USED (Simulated Annealing is Superior) **/
Puzzle PuzzleGenerator::HillClimbing(double timelimit, Puzzle p)
{
	// Function that uses hillclimbing algorithm to find best value puzzle.
	// Returns best puzzle found after timelimit or local max when if it is found before time limit

	Puzzle bestPuzzle = p;

	// Keep track of the time so we don't exceed it.
	Timer t;
	t.StartTimer();

	while (t.GetElapsedTime() < timelimit-0.1)
	{
		// Generate all successors of bestPuzzle
		vector<Puzzle> successors;
		bestPuzzle.GetAllSuccessors(successors);

		Puzzle bestSuccessor = successors[0];

		// Determine highest valued successor and save as new best puzzle
		for (vector<Puzzle>::size_type i = 0; i != successors.size(); i++)
		{
			if (successors[i].GetValue() > bestSuccessor.GetValue())
			{
				bestSuccessor = successors[i];
			}
		}

		// Make sure that best successor is better than its parent (bestPuzzle), save it as the new best puzzle, and loop.
		if (bestSuccessor.GetValue() > bestPuzzle.GetValue())
		{
			bestPuzzle = bestSuccessor;
		}
		else 
		{
			// If it's not better, we found a local maximum. Save it and
			return bestPuzzle;
		}
	}

	printf("time limit reached\n");
	return bestPuzzle;
}