HDOJ 4582

题目大意：

给定一个N个点、M条边的无向图Graph，以及从点1开始进行DFS形成的树Tree，定义"T-Simple Circle"为Graph中的环，要求其中只含一条不属于Tree的边。

将Graph中的一些边进行染色，使得其中每个T-simple Circle都至少包含一条被染色的边，求最少需要染色的边数。

N≤2e3，M≤2e4

本题关键的一点在于Tree是一棵DFS生成树，这样Tree以外的边只可能将某个点与它在Tree中的祖先相连（用反证法可以证明，只有这样才能维持DFS树的性质）。

也就是说，每条Tree以外的边都相当于在DFS生成树上划定了一条深度单调递增（递减）的链，问题转化为：最少染色多少条边，可以使每条链上都至少有一条边被染色。

不难发现，对Tree以外的边进行染色的覆盖效率远小于对Tree上的边进行染色，因此只需考虑DFS生成树的边。

类比直线上的区间选点问题，本题也可以用类似的贪心思路。

题解：http://blog.csdn.net/sd_invol/article/details/9963741

直线上区间选点问题的证明：http://blog.csdn.net/dgq8211/article/details/7534776

C++11代码（貌似HDOJ可以交C++11？）：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <functional>

const int maxN = 2000 + 5;
const int maxM = 20000 + 5;

std::vector<int> toVec[maxN];
int father[maxN]; //father in the DFS tree
int depth[maxN]; //depth in the DFS tree
bool covered[maxN]; //whether the edge (x - father[x]) is covered (used in greedy algorithm)

struct Range
{
    int head, tail; //We guarantee that depth[head] >= depth[tail]

    void swapEndPoint()
    {
        if (depth[head] < depth[tail])
            std::swap(head, tail);
    }
    bool operator < (const Range& rhs) const
    {
        return depth[tail] > depth[rhs.tail] ||
                (depth[tail] == depth[rhs.tail] && depth[head] < depth[rhs.head]);
        //high depth -> 0 --- 0 --- 0 --- 0 --- 0 -> low depth
        //greater:            x --------- x
        //less:         x --------------------- x
    }
};

Range range[maxM];
int N, M;

void init()
{
    memset(father, 0, sizeof(father));
    memset(depth, 0, sizeof(depth));
    memset(covered, 0, sizeof(covered));
    for (int i = 1; i <= N; i++)
        toVec[i].clear();
}

/// @brief swap head and tail so that depth[head] >= depth[tail]
///        this function is called after depth[] is set, before sorting ranges for greedy algorithm
void initRange()
{
    for (int i = 0; i < M - N + 1; i++)
        range[i].swapEndPoint();
}

bool input()
{
    scanf("%d%d", &N, &M);
    if (N == 0)
        return false;

    init();
    for (int u, v, i = 0; i < N - 1; i++) //(N - 1) Edges in DFS tree
    {
        scanf("%d%d", &u, &v);
        toVec[u].push_back(v);
        toVec[v].push_back(u);
    }
    for (int u, v, i = N - 1; i < M; i++)
    {
        scanf("%d%d", &u, &v);
        range[i - N + 1] = {u, v}; //The end points may be swapped later
    }

    return true;
}

///@brief DFS process, setting depth[] and father[]
void dfs(int cur, int last)
{
    father[cur] = last;
    depth[cur] = depth[last] + 1;
    for (auto to: toVec[cur])
    {
        if (to == last)
            continue;
        dfs(to, cur);
    }
}

///@brief wrapper of DFS function
void setDepthAndFather()
{
    depth[0] = 0;
    dfs(1, 0); 
}

int solve()
{
    setDepthAndFather();
    initRange();
    std::sort(range, range + M - N + 1); //(M - N + 1) Edges that does not belong to the DFS tree

    ///@return last if edge (last, father[last]) should be covered
    ///        0 if no edge should be covered in this chain
    auto getCoverEdge = [] (const Range& rg) -> int
    {
        int last = rg.head;

        //higher depth -> head -> tail -> lower depth
        for (int cur = rg.head; cur != rg.tail; cur = father[cur])
        {
            if (covered[cur])
                return 0;
            last = cur;
        }
        return last;
    };

//    ///@debug
//    for (int i = 1; i <= N; i++)
//        printf("father[%d] = %d, depth[%d] = %d
", i, father[i], i, depth[i]);

    int ans = 0;
    for (int i = 0; i < M - N + 1; i++)
    {
        int coverId = getCoverEdge(range[i]);
        if (coverId == 0)
            continue;
        ans += 1;
        covered[coverId] = true;
    }

    return ans;
}

int main()
{
    while (input())
        printf("%d
", solve());
    return 0;
}