线段树

                线段树

/**** **** **** **** **** ****
*    Function Name :         线段树
*    Description :               HDOJ 1542 Atlantis
*                                        用于表示区间线段
**** **** **** **** **** ****/
#include<cstdio>
#include<algorithm>
using namespace std;

typedef struct ITREE_NODE {
     ITREE_NODE * pLChild, * pRChild;
     double left, right;         // 左端点，右端点
     double measure;           // 测度
     int count;                     // 覆盖计数器
     int lines;                       // 独立线段数
     int lbound, rbound;      // 覆盖左、右顶点的线段数目
}*PITREE_NODE;

inline void safe_add(int & v, int value) {
    v += value;
    if (v < 0) v = 0;
}

void itree_splite(const double * pList, PITREE_NODE pParent, const int iLeft, const int iRight) {
    if (iRight - iLeft <= 1) return;
    int iMid = (iLeft + iRight) >> 1;
    pParent -> pLChild = new ITREE_NODE;
    pParent -> pRChild = new ITREE_NODE;
    memset(pParent -> pLChild, 0, sizeof(ITREE_NODE));
    memset(pParent -> pRChild, 0, sizeof(ITREE_NODE));
    pParent -> pLChild -> left = pList[iLeft];
    pParent -> pLChild -> right = pList[iMid];
    pParent -> pRChild -> left = pList[iMid];
    pParent -> pRChild -> right = pList[iRight];
    itree_splite(pList, pParent -> pLChild, iLeft, iMid);
    itree_splite(pList, pParent -> pRChild, iMid, iRight);
}

PITREE_NODE itree_generate(const double * pList, const int iListCount) {
    PITREE_NODE pRoot = new ITREE_NODE;
    memset(pRoot, 0, sizeof(ITREE_NODE));
    pRoot -> left = pList[0];
    pRoot -> right = pList[iListCount - 1];
    itree_splite(pList, pRoot, 0, iListCount - 1);
    return pRoot;
}

void itree_destroy(PITREE_NODE pParent) {
    if (pParent == NULL) return;
    if (pParent -> pLChild) itree_destroy(pParent -> pLChild);
    if (pParent -> pRChild) itree_destroy(pParent -> pRChild);
    delete pParent;
}

inline void itree_measure(PITREE_NODE pNode) {
    if (pNode -> count > 0)
        pNode -> measure = pNode -> right - pNode -> left;
    else if (pNode -> pLChild && pNode -> pRChild)
        pNode -> measure = pNode -> pLChild -> measure + pNode -> pRChild -> measure;
    else
          pNode -> measure = 0;
}

inline void itree_lines(PITREE_NODE pNode) {
    if (pNode -> count > 0) {
        pNode -> lines = 1;
    } else if (pNode -> pLChild && pNode -> pRChild) {
        if (pNode -> pLChild -> rbound && pNode -> pRChild -> lbound) {
            pNode -> lines = pNode -> pLChild -> lines + pNode -> lines - 1;
        } else {
            pNode -> lines = pNode -> pLChild -> lines + pNode -> lines;
        }
    } else {
        pNode -> lines = 0;
    }
}

// 插入的时候value = 1, 删除的时候value = -1
void itree_update(PITREE_NODE pParent, const double left, const double right,
                  int value) {
    if (pParent -> left == left && pParent -> right == right) {
        safe_add(pParent -> count, value);
        safe_add(pParent -> lbound, value);
        safe_add(pParent -> rbound, value);
        itree_measure(pParent);
        itree_lines(pParent);
    } else {
        if (pParent -> pLChild -> right > left) {
            if (pParent -> pLChild -> right >= right) {
                itree_update(pParent -> pLChild, left, right, value);
            } else {
                itree_update(pParent -> pLChild, left,
                         pParent -> pLChild -> right, value);
                itree_update(pParent -> pRChild, pParent -> pRChild -> left,
                         right, value);
            }
        } else {
            itree_update(pParent -> pRChild, left, right, value);
        }
        itree_measure(pParent);
        itree_lines(pParent);
        if (left == pParent -> left) safe_add(pParent -> lbound, value);
          if (right == pParent -> right) {
            safe_add(pParent -> rbound, value);
        }
    }
}

void itree_insert(PITREE_NODE pParent, const double left, const double right) {itree_update(pParent, left, right, 1);}

void itree_delete(PITREE_NODE pParent, const double left, const double right) {itree_update(pParent, left, right, -1);}

struct EVENT {
     double x, y1, y2;
     int type;
};

bool cmp(const EVENT & a, const EVENT & b) 

{ return a.x < b.x;}

PITREE_NODE pRoot;
EVENT env[200];
double Y[200];
double tsize = 0.0;

int main() {
    double x1, x2, y1, y2;
    int i, n, n2, cas = 0;
    while (scanf("%d", & n) == 1 && n) {
        cas++;
        n2 = n << 1;
        for (i = 0; i < n2; i += 2) {
            scanf("%lf%lf%lf%lf", & x1, & y1, & x2, & y2);
            env[i].x = x1;
            env[i].y1 = y1;
            env[i].y2 = y2;
            env[i].type = 1;
            env[i + 1].x = x2;
            env[i + 1].y1 = y1;
            env[i + 1].y2 = y2;
            env[i + 1].type = -1;
            Y[i] = y1;
            Y[i + 1] = y2;
        }
        sort(env, env + n2, cmp);
        sort(Y, Y + n2);
        pRoot = itree_generate(Y, n2);
        for (i = 0; i < n2; ++i) {
            if (i > 0) tsize += pRoot -> measure * (env[i].x - env[i - 1].x);
            else tsize = 0.0;
            itree_update(pRoot, env[i].y1, env[i].y2, env[i].type);
        }
        itree_destroy(pRoot);
        printf("Test case #%d\nTotal explored area: %.2lf\n\n", cas, tsize);
    }
    return 0;
}