VrpHeurTSP.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of a solver for the Vehicle Routing Problem             *
 * developed using the BiCePS Linear Integer Solver (BLIS).                  *
 *                                                                           *
 * This solver is distributed under the Eclipse Public License as part of    * 
 * the COIN-OR repository (http://www.coin-or.org).                          *
 *                                                                           *
 * Authors: Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *                                                                           *
 * Copyright (C) 2007 Yan Xu and Ted Ralphs.                                 *
 * All Rights Reserved.                                                      *
 *===========================================================================*/

#ifndef VrpHeurTSP_h_
#define VrpHeurTSP_h_

//#############################################################################

#include <vector>

#include "CoinPackedVector.hpp"

#include "BlisHeuristic.h"
#include "VrpModel.h"

//#############################################################################
#if 0
class VrpAdjList 
{
private:
    std::vector<CoinPackedVector *> list_;
    VrpModel *model_;
public:
    VrpAdjList() {}
    VrpAdjList(VrpModel *m) { 
        model_ = m; 
        createAdjList(m);
    }
    
    void createAdjList(VrpModel *model);
};

typedef struct vrp_neighbors 
{
    int n1;
    int n2;
} VrpNeighbors;

#endif

//#############################################################################

class VrpHeurTSP : public BlisHeuristic {
private:
    VrpHeurTSP & operator=(const VrpHeurTSP& rhs);
    
protected:
    /* Stored the predetermined next vertex to visit for vertex k if 
       the value determined_[k] greater than zero. */
    //int *determined_;
    
    /* Adjacent list of all vertices. */
    std::vector<CoinPackedVector *> adjList_;

    void createAdjList(VrpModel *model);

    std::vector<int> tour_;
    
    bool *visited_;

    int preNode_;

    //VrpNeighbor *
    int *neighbors_;

    int nodeCalls_;
    
    std::vector<int> *edgeColMatch_;
    
    void freeGuts() {
        if (visited_) {
            delete [] visited_;
            visited_ = NULL;
        }
        int numVertices = adjList_.size();
        for (int k = 0; k < numVertices; ++k) {
            delete adjList_[k];
        }
        adjList_.clear();
        if (neighbors_) {
            delete [] neighbors_;
            neighbors_ = NULL;
        }
        if (edgeColMatch_) {
            delete [] edgeColMatch_;
            edgeColMatch_ = NULL;
        }
    }

public:
    VrpHeurTSP()
        : 
        visited_(0), preNode_(-1), 
        neighbors_(0), nodeCalls_(0), edgeColMatch_(0) {}
    
    VrpHeurTSP(VrpModel * model, const char *name,
               BlisHeurStrategy strategy, int freq)
        :
        BlisHeuristic(model, name, strategy, freq)
    { 
        visited_ = NULL;
        preNode_ = -1;
        neighbors_ = NULL;
        nodeCalls_ = 0;
        edgeColMatch_ = NULL;
        createAdjList(model);
    }

    ~VrpHeurTSP() 
    { 
        freeGuts();
    }
    
    virtual bool searchSolution(double & objectiveValue, double * newSolution);
};
#endif

//#############################################################################