Facility Location Problem (FLP)

import hexaly.optimizer
import sys

def read_integers(filename):
    with open(filename) as f:
        return [int(elem) for elem in f.read().split()]

#
# Read instance data
#
def read_instance(instance_file):
    file_it = iter(read_integers(instance_file))
    # Number of locations
    N = next(file_it)
    next(file_it) # Skip number of edges
    # Size of the subset S of facilities
    p = next(file_it)

    # w: Weight matrix of the shortest path between locations
    # wmax: Maximum distance between two locations
    wmax = 0
    w = [None] * N
    for i in range(N):
        w[i] = [None] * N
        for j in range(N):
            w[i][j] = next(file_it)
            if w[i][j] > wmax:
                wmax = w[i][j]

    return N, p, wmax, w

def main(instance_file, output_file, time_limit):
    N, p, wmax, w = read_instance(instance_file)

    with hexaly.optimizer.HexalyOptimizer() as optimizer:
        #
        # Declare the optimization model
        #
        m = optimizer.model

        # One variable for each location: 1 if facility, 0 otherwise
        x = [m.bool() for i in range(N)]

        # No more than p locations are selected to be facilities
        opened_locations = m.sum(x[i] for i in range(N))
        m.constraint(opened_locations <= p)

        # Costs between location i and j is w[i][j] if j is a facility or 2 * wmax if not
        costs = [None] * N
        for i in range(N):
            costs[i] = [None] * N
            for j in range(N):
                costs[i][j] = m.iif(x[j], w[i][j], 2 * wmax)

        # Cost between location i and the closest facility
        cost = [None] * N
        for i in range(N):
            cost[i] = m.min(costs[i][j] for j in range(N))

        # Minimize the total cost
        total_cost = m.sum(cost[i] for i in range(N))
        m.minimize(total_cost)

        m.close()

        # Parameterize the optimizer
        optimizer.param.time_limit = time_limit

        optimizer.solve()

        #
        # Write the solution in a file with the following format:
        # - value of the objective
        # - indices of the facilities (between 0 and N-1)
        #
        if output_file is not None:
            with open(output_file, 'w') as f:
                f.write("%d\n" % total_cost.value)
                for i in range(N):
                    if x[i].value == 1:
                        f.write("%d " % i)
                f.write("\n")

if __name__ == '__main__':
    if len(sys.argv) < 2:
        print("Usage: python facility_location.py instance_file [output_file] [time_limit]")
        sys.exit(1)

    instance_file = sys.argv[1]
    output_file = sys.argv[2] if len(sys.argv) >= 3 else None
    time_limit = int(sys.argv[3]) if len(sys.argv) >= 4 else 20
    main(instance_file, output_file, time_limit)

#include "optimizer/hexalyoptimizer.h"
#include <fstream>
#include <iostream>
#include <sstream>
#include <vector>

using namespace hexaly;
using namespace std;

class Facilitylocation {
public:
    // Number of locations
    int N;

    // Size of the subset S of facilities
    int p;

    // Weight matrix of the shortest path between locations
    vector<vector<int>> w;

    // Maximum distance between two locations
    int wmax;

    // Hexaly Optimizer
    HexalyOptimizer optimizer;

    // Decisions variables
    vector<HxExpression> x;

    // Objective
    HxExpression totalCost;

    // Read instance data
    void readInstance(const string& fileName) {
        ifstream infile;
        infile.exceptions(ifstream::failbit | ifstream::badbit);
        infile.open(fileName.c_str());

        int tmp;
        infile >> N;
        infile >> tmp; // Skip number of edges
        infile >> p;

        w.resize(N);
        wmax = 0;
        for (int i = 0; i < N; ++i) {
            w[i].resize(N);
            for (int j = 0; j < N; ++j) {
                infile >> w[i][j];
                if (w[i][j] > wmax) {
                    wmax = w[i][j];
                }
            }
        }
    }

    // Declare the optimization model
    void solve(int limit) {
        HxModel m = optimizer.getModel();

        // One variable for each location: 1 if facility, 0 otherwise
        x.resize(N);
        for (int i = 0; i < N; ++i)
            x[i] = m.boolVar();

        // No more than p locations are selected to be facilities
        HxExpression openedLocations = m.sum(x.begin(), x.end());
        m.constraint(openedLocations <= p);

        // Costs between location i and j is w[i][j] if j is a facility or 2 * wmax if not
        vector<vector<HxExpression>> costs(N);
        for (int i = 0; i < N; ++i) {
            costs[i].resize(N);
            for (int j = 0; j < N; ++j) {
                costs[i][j] = m.iif(x[j], w[i][j], 2 * wmax);
            }
        }

        // Cost between location i and the closest facility
        vector<HxExpression> cost(N);
        for (int i = 0; i < N; ++i) {
            cost[i] = m.min(costs[i].begin(), costs[i].end());
        }

        // Minimize the total cost
        totalCost = m.sum(cost.begin(), cost.end());
        m.minimize(totalCost);
        m.close();

        // Parameterize the optimizer
        optimizer.getParam().setTimeLimit(limit);

        optimizer.solve();
    }

    /* Write the solution in a file with the following format: 
     * - value of the objective
     * - indices of the facilities (between 0 and N-1) */
    void writeSolution(const string& fileName) {
        ofstream outfile;
        outfile.exceptions(ofstream::failbit | ofstream::badbit);
        outfile.open(fileName.c_str());

        outfile << totalCost.getValue() << endl;
        for (int i = 0; i < N; ++i) {
            if (x[i].getValue() == 1)
                outfile << i << " ";
        }
        outfile << endl;
    }
};

int main(int argc, char** argv) {
    if (argc < 2) {
        cerr << "Usage: facility_location inputFile [outputFile] [timeLimit] " << endl;
        return 1;
    }

    const char* instanceFile = argv[1];
    const char* solFile = argc > 2 ? argv[2] : NULL;
    const char* strTimeLimit = argc > 3 ? argv[3] : "20";

    try {
        Facilitylocation model;
        model.readInstance(instanceFile);
        model.solve(atoi(strTimeLimit));
        if (solFile != NULL)
            model.writeSolution(solFile);
        return 0;
    } catch (const exception& e) {
        cerr << "An error occurred: " << e.what() << endl;
        return 1;
    }
}

using System;
using System.IO;
using System.Collections.Generic;
using Hexaly.Optimizer;

public class FacilityLocation : IDisposable
{
    // Number of locations
    int N;

    // Size of the subset S of facilities
    int p;

    // Weight matrix of the shortest path beween locations
    int[][] w;

    // Maximum distance between two locations
    int wmax;

    // Hexaly Optimizer
    HexalyOptimizer optimizer;

    // Decision variables
    HxExpression[] x;

    // Objective
    HxExpression totalCost;

    // List of facilities
    List<int> solution;

    public FacilityLocation()
    {
        optimizer = new HexalyOptimizer();
    }

    // Read instance data
    public void ReadInstance(string fileName)
    {
        using (StreamReader input = new StreamReader(fileName))
        {
            var tokens = input.ReadLine().Split(' ');
            N = int.Parse(tokens[0]);
            p = int.Parse(tokens[2]);

            w = new int[N][];
            wmax = 0;
            for (int i = 0; i < N; ++i)
            {
                tokens = input.ReadLine().Split(' ');
                w[i] = new int[N];
                for (int j = 0; j < N; ++j)
                {
                    w[i][j] = int.Parse(tokens[j]);
                    if (w[i][j] > wmax)
                        wmax = w[i][j];
                }
            }
        }
    }

    public void Dispose()
    {
        if (optimizer != null)
            optimizer.Dispose();
    }

    // Declare the optimization model
    public void Solve(int limit)
    {
        optimizer = new HexalyOptimizer();
        HxModel model = optimizer.GetModel();
        x = new HxExpression[N];

        // One variable for each location: 1 if facility, 0 otherwise
        for (int i = 0; i < N; ++i)
            x[i] = model.Bool();

        // No more than p locations are selected to be facilities
        HxExpression openedLocations = model.Sum(x);
        model.Constraint(openedLocations <= p);

        // Costs between location i and j is w[i][j] if j is a facility or 2 * wmax if not
        HxExpression[][] costs = new HxExpression[N][];
        for (int i = 0; i < N; ++i)
        {
            costs[i] = new HxExpression[N];
            for (int j = 0; j < N; ++j)
                costs[i][j] = model.If(x[j], w[i][j], 2 * wmax);
        }

        // Cost between location i and the closest facility
        HxExpression[] cost = new HxExpression[N];
        for (int i = 0; i < N; ++i)
            cost[i] = model.Min(costs[i]);

        // Minimize the total cost
        totalCost = model.Sum(cost);
        model.Minimize(totalCost);

        model.Close();

        // Parameterize the optimizer
        optimizer.GetParam().SetTimeLimit(limit);
        optimizer.Solve();

        solution = new List<int>();
        for (int i = 0; i < N; ++i)
            if (x[i].GetValue() == 1)
                solution.Add(i);
    }

    /* Write the solution in a file with the following format:
     * - value of the objective
     * - indices of the facilities (between 0 and N-1) */
    public void WriteSolution(string fileName)
    {
        using (StreamWriter output = new StreamWriter(fileName))
        {
            output.WriteLine(totalCost.GetValue());
            for (int i = 0; i < N; ++i) {
                if (x[i].GetValue() == 1)
                    output.Write(i + " ");
            }
            output.WriteLine();
        }
    }

    public static void Main(string[] args)
    {
        if (args.Length < 1)
        {
            Console.WriteLine("Usage: Facilitylocation inputFile [outputFile] [timeLimit]");
            Environment.Exit(1);
        }
        string instanceFile = args[0];
        string outputFile = args.Length > 1 ? args[1] : null;
        string strTimeLimit = args.Length > 2 ? args[2] : "20";

        using (FacilityLocation model = new FacilityLocation())
        {
            model.ReadInstance(instanceFile);
            model.Solve(int.Parse(strTimeLimit));
            if (outputFile != null)
                model.WriteSolution(outputFile);
        }
    }
}

import java.util.*;
import java.io.*;
import com.hexaly.optimizer.*;

public class Facilitylocation {
    // Number of locations
    private int N;

    // Size of the subset S of facilities
    private int p;

    // Weight matrix of the shortest path between locations
    private int[][] w;

    // Maximum distance between two locations
    private int wmax;

    // Hexaly Optimizer.
    private final HexalyOptimizer optimizer;

    // Decisions variables
    private HxExpression[] x;

    // Objective
    private HxExpression totalCost;

    private Facilitylocation(HexalyOptimizer optimizer) {
        this.optimizer = optimizer;
    }

    // Read instance data
    private void readInstance(String fileName) throws IOException {
        try (Scanner input = new Scanner(new File(fileName))) {
            N = input.nextInt();
            input.nextInt(); // Skip number of edges
            p = input.nextInt();

            w = new int[N][N];
            wmax = 0;
            for (int i = 0; i < N; ++i) {
                for (int j = 0; j < N; ++j) {
                    w[i][j] = input.nextInt();
                    if (w[i][j] > wmax)
                        wmax = w[i][j];
                }
            }
        }
    }

    private void solve(int limit) {
        // Declare the optimization model
        HxModel model = optimizer.getModel();

        // One variable for each location: 1 if facility, 0 otherwise
        x = new HxExpression[N];
        for (int i = 0; i < N; ++i) {
            x[i] = model.boolVar();
        }

        // No more than p locations are selected to be facilities
        HxExpression openedLocations = model.sum(x);
        model.constraint(model.leq(openedLocations, p));

        // Costs between location i and j is w[i][j] if j is a facility or 2 * wmax if not
        HxExpression[][] costs = new HxExpression[N][N];
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                costs[i][j] = model.iif(x[j], w[i][j], 2 * wmax);
            }
        }

        // Cost between location i and the closest facility
        HxExpression[] cost = new HxExpression[N];
        for (int i = 0; i < N; ++i) {
            cost[i] = model.min(costs[i]);
        }

        // Minimize the total cost
        totalCost = model.sum(cost);
        model.minimize(totalCost);

        model.close();

        // Parameterize the optimizer
        optimizer.getParam().setTimeLimit(limit);
        optimizer.solve();
    }

    /* Write the solution in a file with the following format:
     * - value of the objective
     * - indices of the facilities (between 0 and N-1) */
    private void writeSolution(String fileName) throws IOException {
        try (PrintWriter output = new PrintWriter(fileName)) {
            output.println(totalCost.getValue());
            for (int i = 0; i < N; ++i) {
                if (x[i].getValue() == 1)
                    output.print(i + " ");
            }
        }
    }

    public static void main(String[] args) {
        if (args.length < 1) {
            System.err.println("Usage: java Facilitylocation inputFile [outputFile] [timeLimit]");
            System.exit(1);
        }

        String instanceFile = args[0];
        String outputFile = args.length > 1 ? args[1] : null;
        String strTimeLimit = args.length > 2 ? args[2] : "20";

        try (HexalyOptimizer optimizer = new HexalyOptimizer()) {
            Facilitylocation model = new Facilitylocation(optimizer);
            model.readInstance(instanceFile);
            model.solve(Integer.parseInt(strTimeLimit));
            if (outputFile != null) {
                model.writeSolution(outputFile);
            }
        } catch (Exception ex) {
            System.err.println(ex);
            ex.printStackTrace();
            System.exit(1);
        }
    }
}