cut_structs.hpp

#ifndef CMR_CUT_STRUCTS_H
#define CMR_CUT_STRUCTS_H

#include "util.hpp"

#include <utility>
#include <vector>

namespace CMR {
namespace Sep {

struct ex_blossom {
    ex_blossom(std::vector<int> &_handle, int _cut_edge, double _val) :
        handle(_handle), cut_edge(_cut_edge), cut_val(_val){}

    std::vector<int> handle;

    int cut_edge;

    double cut_val;
};

struct ToothBody : Segment {
    ToothBody() = default;
    ToothBody(int _start, int _end, double _slack) :
        Segment(_start, _end), slack(_slack) {}
    ToothBody(int _start, int _end) : Segment(_start, _end), slack(1.0) {}

    double slack;
};

struct SimpleTooth {
    SimpleTooth(int _root, int _body_start, int _body_end, double _slack) :
        root(_root), body_start(_body_start), body_end(_body_end),
        slack(_slack) {}

    SimpleTooth(int _root, ToothBody &seg, double _slack) :
        root(_root), body_start(seg.start), body_end(seg.end), slack(_slack) {}

    using Ptr = std::unique_ptr<SimpleTooth>;

    int root, body_start, body_end;
    int cutgraph_index;
    double slack;

    enum Type {
        LeftAdj = 0,
        RightAdj = 1,
        Dist = 2
    };

    Type type() const
        {
            if (body_start == root + 1)
                return LeftAdj;
            if (body_end + 1 == root)
                return RightAdj;
            return Dist;
        }

    int body_size() const { return body_end - body_start + 1; }
    bool body_contains(int i) const { return body_start <= i && i <= body_end; }
    bool is_subset_of(const SimpleTooth &T) const {
        return root == T.root &&
        T.body_start <= body_start &&
        body_end <= T.body_end;
    }

};

struct dominoparity {
    dominoparity() = default;
    dominoparity(std::vector<SimpleTooth> &_used_teeth,
                 std::vector<int> &_degree_nodes,
                 std::vector<std::pair<int, int>> &_nonneg_edges) :
        used_teeth(_used_teeth), degree_nodes(_degree_nodes),
        nonneg_edges(_nonneg_edges) {}

    std::vector<SimpleTooth> used_teeth;

    std::vector<int> degree_nodes;

    std::vector<std::pair<int, int>> nonneg_edges;
};

}
}



#endif