SSPInstance.java

package com.aim.project.ssp.instance;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
import com.aim.project.ssp.SSPObjectiveFunction;
import com.aim.project.ssp.interfaces.ObjectiveFunctionInterface;
import com.aim.project.ssp.interfaces.SSPInstanceInterface;
import com.aim.project.ssp.interfaces.SSPSolutionInterface;
import com.aim.project.ssp.interfaces.SolutionRepresentationInterface;
import com.aim.project.ssp.solution.SSPSolution;
import com.aim.project.ssp.solution.SolutionRepresentation;

/**
 * Represents an SSP instance with various locations, including a hotel, an airport,
 * and points of interest. The instance can generate solutions using different initialization modes.
 *
 * @author Sushant Nepal
 * @since 17/03/2025
 */
public class SSPInstance implements SSPInstanceInterface {

	private final Location[] aoLocations;
	private final Location oHotelLocation;
	private final Location oAirportLocation;
	private final int iNumberOfLocations;
	private final Random oRandom;
	private final ObjectiveFunctionInterface f;

	/**
	 * Constructs an SSPInstance with the given data.
	 *
	 * @param iNumberOfLocations The number of sightseeing locations.
	 * @param aoLocations An array of all the locations.
	 * @param oHotelLocation The location of the hotel.
	 * @param oAirportLocation The location of the airport.
	 * @param random A Random instance for generating random values.
	 */
	public SSPInstance(int iNumberOfLocations, Location[] aoLocations, Location oHotelLocation, Location oAirportLocation, Random random) {
		this.iNumberOfLocations = iNumberOfLocations;
		this.oRandom = random;
		this.aoLocations = aoLocations;
		this.oHotelLocation = oHotelLocation;
		this.oAirportLocation = oAirportLocation;
		this.f = new SSPObjectiveFunction(this);
	}

	/**
	 * Creates a solution based on the specified initialization mode.
	 *
	 * @param mode The mode for solution initialization (Random or Constructive).
	 * @return A new SSPSolution instance representing the solution.
	 * @throws IllegalArgumentException If an unsupported initialization mode is provided.
	 */
	@Override
	public SSPSolution createSolution(InitialisationMode mode) {
		int[] tour;

		if (mode == InitialisationMode.RANDOM) {
			tour = generateRandomTour();
		} else if (mode == InitialisationMode.CONSTRUCTIVE) {
			tour = generateGreedyTour();
		} else {
			throw new IllegalArgumentException("Unsupported InitialisationMode: " + mode);
		}

		// Create solution representation and calculate the cost
		SolutionRepresentationInterface solution = new SolutionRepresentation(tour);
		double cost = f.getObjectiveFunctionValue(solution);
		return new SSPSolution(solution, cost);
	}

	/**
	 * Generates a random tour by shuffling the sightseeing locations.
	 *
	 * @return An array representing a random sightseeing tour.
	 */
	private int[] generateRandomTour() {
		ArrayList<Integer> sightseeingIndices = new ArrayList<>();
		for (int i = 0; i < iNumberOfLocations; i++) {
			sightseeingIndices.add(i);
		}
		Collections.shuffle(sightseeingIndices, oRandom);

		// Convert the shuffled list into an array
		int[] tour = new int[iNumberOfLocations];
		for (int i = 0; i < iNumberOfLocations; i++) {
			tour[i] = sightseeingIndices.get(i);
		}

		return tour;
	}

	/**
	 * Generates a greedy tour by iteratively choosing the nearest unvisited location.
	 *
	 * @return An array representing a greedy sightseeing tour.
	 */
	private int[] generateGreedyTour() {
		int[] tour = new int[iNumberOfLocations];
		boolean[] visited = new boolean[iNumberOfLocations];
		Arrays.fill(visited, false);

		// Start with the nearest location to the hotel
		int currentIndex = findNearestLocationToHotel();
		tour[0] = currentIndex;
		visited[currentIndex] = true;

		// Find the nearest unvisited locations to form the rest of the tour
		for (int i = 1; i < iNumberOfLocations; i++) {
			int nearestIndex = -1;
			double nearestDistance = Double.MAX_VALUE;

			// Find the closest unvisited location
			for (int j = 0; j < iNumberOfLocations; j++) {
				if (!visited[j]) {
					double distance = f.getCost(currentIndex, j);
					if (distance < nearestDistance) {
						nearestDistance = distance;
						nearestIndex = j;
					}
				}
			}
			tour[i] = nearestIndex;
			visited[nearestIndex] = true;
			currentIndex = nearestIndex;
		}

		return tour;
	}

	/**
	 * Finds the nearest sightseeing location to the hotel.
	 *
	 * @return The index of the nearest sightseeing location to the hotel.
	 */
	private int findNearestLocationToHotel() {
		double nearestHotel = Double.MAX_VALUE;
		int nearestLocation = -1;

		for (int i = 0; i < iNumberOfLocations; i++) {
			double distance = f.getCostBetweenHotelAnd(i);
			if (distance < nearestHotel) {
				nearestHotel = distance;
				nearestLocation = i;
			}
		}
		return nearestLocation;
	}

	/**
	 * Retrieves the objective function associated with this SSP instance.
	 *
	 * @return The objective function.
	 */
	@Override
	public ObjectiveFunctionInterface getSSPObjectiveFunction() {
		return f;
	}

	/**
	 * Returns the total number of locations, including the hotel and airport.
	 *
	 * @return The total number of locations.
	 */
	@Override
	public int getNumberOfLocations() {
		return iNumberOfLocations + 2; // Including hotel and airport
	}

	/**
	 * Retrieves a specific sightseeing location by its ID.
	 *
	 * @param iLocationId The ID of the location to retrieve.
	 * @return The corresponding Location object.
	 * @throws IllegalArgumentException If the location ID is invalid.
	 */
	@Override
	public Location getSightseeingLocation(int iLocationId) {
		if (iLocationId < 0 || iLocationId >= iNumberOfLocations) {
			throw new IllegalArgumentException("Invalid sightseeing location ID: " + iLocationId);
		}
		return aoLocations[iLocationId];
	}

	/**
	 * Retrieves the hotel location.
	 *
	 * @return The hotel location.
	 */
	@Override
	public Location getHotelLocation() {
		return oHotelLocation;
	}

	/**
	 * Retrieves the airport location.
	 *
	 * @return The airport location.
	 */
	@Override
	public Location getAirportLocation() {
		return oAirportLocation;
	}

	/**
	 * Converts a solution representation to a list of locations.
	 *
	 * @param oSolution The solution to convert.
	 * @return A list of locations representing the solution.
	 */
	@Override
	public ArrayList<Location> getSolutionAsListOfLocations(SSPSolutionInterface oSolution) {
		int[] representation = oSolution.getSolutionRepresentation().getSolutionRepresentation();
		ArrayList<Location> tourLocations = new ArrayList<>();

		for (int locationId : representation) {
			tourLocations.add(aoLocations[locationId]);
		}

		return tourLocations;
	}
}