poj3417Network（LCA+dfs）

题意：给一个树，然后又在树上加了好多的边，现在问你删除一条原先的边和新加的边的一条，有多少中方法使得树不连通

思路：对于新加的一条边来说，肯定会与之前的树形成一个环，而此时环内的所有边删除并且新加的这条变也删除就会是一种方案，而这道题是将所有新边都加入后的情况，那么我们看每条边，如果没有与它形成环的情况，那么这条边删除肯定会使得图不连通，那么情况就会加M，也就是和新加的M条边任意组合都可以，对于新加的边它形成的环内的所有变的权值都加1，那么对于树上的边如果最后权值为1，说明它只与一条新边形成了环，那么删除这两条变就会多一种情况，最后将所有的都统计出来就行了,另外这个题目卡时间，用cin取消同步又过不了。。只能用scanf了

#include <iostream>
#include <string.h>
#include <stdio.h>
using namespace std;
const int maxn=120010;
const int maxm=40;
int dp[2*maxn][maxm];//这个数组记得开到2*maxn，因为遍历后序列长度为2*n-1
bool vis[maxn];
struct edge
{
    int u,v,w,next;
} e[2*maxn];
int tot,tot2,head[maxn];
int ver[2*maxn],R[maxn*2],first[maxn];
long long sum[2*maxn];
int dis[maxn];
ver:节点编号 R：深度 first：点编号位置 dis：距离
inline void addedge(int u,int v,int w)
{
    e[tot2].u=u;
    e[tot2].v=v;
    e[tot2].w=w;
    e[tot2].next=head[u];
    head[u]=tot2++;
    e[tot2].u=v;
    e[tot2].v=u;
    e[tot2].w=w;
    e[tot2].next=head[v];
    head[v]=tot2++;
}

void dfs(int u,int dep)
{
    vis[u]=true;
    ver[++tot]=u;
    first[u]=tot;
    R[tot]=dep;
    for(int k=head[u]; k!=-1; k=e[k].next)
    {
        if(!vis[e[k].v])
        {
            int v=e[k].v;
            int w=e[k].w;
            dis[v]=dis[u]+w;
            dfs(v,dep+1);
            ver[++tot]=u;
            R[tot]=dep;
        }
    }
}
void ST(int n)
{
    for(int i=1; i<=n; i++)
        dp[i][0]=i;
    for(int j=1; (1<<j)<=n; j++)
    {
        for(int i=1; i+(1<<j)-1<=n; i++)
        {
            int a=dp[i][j-1];
            int b=dp[i+(1<<(j-1))][j-1];
            dp[i][j]=R[a]<R[b]?a:b;
        }
    }
}
int rmq(int l,int r)
{
    int k=0;
    while((1<<(k+1))<=r-l+1)
        k++;
    int a=dp[l][k];
    int b=dp[r-(1<<k)+1][k];//保存的是编号，而且第二维保存的是长度
    return R[a]<R[b]?a:b;
}
int LCA(int u,int v)
{
    int x=first[u];
    int y=first[v];
    if(x>y)
        swap(x,y);
    int res=rmq(x,y);
    return ver[res];
}//以上是LCA模板
void dfs2(int x,int fa)
{
    for(int i=head[x]; i!=-1; i=e[i].next)
    {
        int t=e[i].v;
        if(t==fa)
            continue;
        dfs2(t,x);
        sum[x]+=sum[t];
    }
}
void init()
{
    memset(head,-1,sizeof(head));
    memset(vis,0,sizeof(vis));
    memset(ver,0,sizeof(ver));
    memset(dp,0,sizeof(dp));
    memset(R,0,sizeof(R));
    memset(dis,0,sizeof(dis));
    memset(sum,0,sizeof(sum));
    tot2=0;
}
int main()
{
    int n,m;
    //ios::sync_with_stdio(false);
   // while(cin>>n>>m)
   while(scanf("%d%d",&n,&m)!=EOF)
    {
        init();
        for(int i=1; i<=n-1; i++)
        {
            int u,v,w;
            w=0;
            //cin>>u>>v;
            scanf("%d%d",&u,&v);
            addedge(u,v,w);
        }
        tot=0;
        vis[1]=1;
        dfs(1,1);
        ST(2*n-1);
        for(int i=1;i<=m;i++)
        {
            int u,v;
           // cin>>u>>v;
           scanf("%d%d",&u,&v);
            int lca=LCA(u,v);
            sum[u]++;
            sum[v]++;
            sum[lca]-=2;//这里要注意，我们虽然说得是边，但实际上是用点来代替的，就是点代替上边的那条边，而且我们每次加一条边成环，那么我们只需要找到最近公共祖先就行了，上边的不用管，然后最近公共祖先的这个点的上边不需要加，但是我却多加了2，所以要减掉
        }
        dfs2(1,1);
        long long ans=0;
        for(int i=2; i<=n; i++)/不能计算第一个点，它上边没有边，而且算了可能会出错
        {
            if(sum[i]==0)
                ans+=m;
            else if(sum[i]==1)
                ans++;
           // else if(sum[i]>=2)
           //     continue;
        }
        //cout<<ans<<endl;
        printf("%lld\n",ans);
    }
    return 0;
}