hdu--4912--终于解脱了

....历经n发wa之后 终于解脱了

这感觉....无法言表...

其实 这题你说难吧？ 对于我而言 一共就做过一道lca的人来说 是有点难的

可是吧 当你慢慢地写下来 其实代码那么长 又不怎么难

对于此题 就是先求出query中2个结点的lca之后 然后dfs它们的lca 根据深度进行排序

这个其实不难理解吧？ 当然深度越大的 就是离根结点越远 首先进行搜索

然后 就是每搜到一个点 就将它进行标记-已访问过

深搜的时候 注意下 不仅要判断是否访问过 而且要判断这2点的深度关系 肯定是从小的搜到大的

最最注意的就是

depth[v] = depth[u] + 1这句话 不要太随意地写在了lca_tarjan(v)的后面

表示 我就一不留神 写错了 找了好久。。

其余的 就是可以再去好好思索下lca_tarjan的整个算法实现过程

准备 可能 晚上再去学校lca的在线算法...

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

int Ncnt , Qcnt;
const int size = 100010;
struct data
{
    int id;
    int from;
    int to;
    int next;
    int lca;
};
data node[size*2];
int Nhead[size];
data query[size*2];
data graph[size];
int Qhead[size];
bool vis[size];
int father[size];
int depth[size];
bool check[size];

bool cmp( data p , data q )
{
    return depth[p.lca] > depth[q.lca];
}

void init( )
{
    memset( Nhead , -1 , sizeof(Nhead) );
    memset( Qhead , -1 , sizeof(Qhead) );
    memset( vis , false , sizeof(vis) );
    memset( check , false , sizeof(check) );
    depth[1] = 0;
}

int find( int x )
{
    return x == father[x] ? x : father[x] = find( father[x] );
}

void addNedge( int st , int end )
{
    node[Ncnt].to = end;
    node[Ncnt].next = Nhead[st];
    Nhead[st] = Ncnt ++;
}

void addQedge( int id , int st , int end )
{
    query[Qcnt].id = id;
    query[Qcnt].from = st;
    query[Qcnt].to = end;
    query[Qcnt].next = Qhead[st];
    Qhead[st] = Qcnt ++;
}

void lca_tarjan( int u )
{
    int v;
    father[u] = u;
    vis[u] = true;
    for( int i = Nhead[u] ; ~i ; i = node[i].next )
    {
        v = node[i].to;
        if( !vis[v] )
        {
            depth[v] = depth[u] + 1;
            lca_tarjan( v );
            father[v] = u;
        }
    }
    for( int i = Qhead[u] ; ~i ; i = query[i].next )
    {
        v = query[i].to;
        if( vis[v] )
        {
            graph[ query[i].id ].lca = find(v);
        }
    }
}    

void dfs( int u )
{
    int v;
    check[u] = true;
    for( int i = Nhead[u] ; ~i ; i = node[i].next )
    {
        v = node[i].to;
        if( !check[v] && depth[u]<depth[v] )
            dfs(v);
    }
}

int main()
{
    cin.sync_with_stdio(false);
    int n , m , st , end , lca , ans , temp;
    while( cin >> n >> m )
    {
        ans = Ncnt = Qcnt = 0;
        init( );
        for( int i = 0 ; i<n-1 ; i++ )
        {
            cin >> st >> end;
            addNedge( st , end );
            addNedge( end , st );
        }
        for( int i = 0 ; i<m ; i++ )
        {
            cin >> st >> end;
            addQedge( i , st , end );
            addQedge( i , end , st );
            graph[i].from = st;
            graph[i].to = end;
        }
        lca_tarjan(1);
        sort( graph , graph+m , cmp );
        for( int i = 0 ; i<m ; i++ )
        {
            st = graph[i].from;
            end = graph[i].to;
            lca = graph[i].lca;
            if( !check[st] && !check[end] )
            {
                ans ++;
                dfs( lca );
            }
        }
        cout << ans << endl;
    }
    return 0;
}

today:

　　关于思念你的这件小事

　　躲得过对酒当歌的夜晚

　　躲不过四下无人的街道