<更新提示>
<第一次更新>
<正文>
寝室管理
Description
T64有一个好朋友，叫T128。T128是寄宿生，并且最近被老师叫过去当宿管了。
宿管可不是一件很好做的工作，碰巧T128有一个工作上的问题想请T64帮忙解决。T128的寝室条件不是很好，所以没有很多钱来装修。礼间寝室仅由n-1条双向道路连接，而且任意两间寝室之间都可以互达。最近，T128被要求对一条路径上的所有寝室进行管理，这条路径不会重复经过某个点或某条边。但他不记得是哪条路径了。他只记得这条路径上有不少于k个寝室。于是，他想请T64帮忙数一下，有多少条这样的路径满足条件。嗯…还有一个问题。由于最近有一些熊孩子不准晚上讲话很不爽，他们决定修筑一条“情报通道”，如果通道建成，寝室就变成了一个N个点N条边的无向图。并且，经过“情报通道”的路径也是合法的。
T128心想：通道建成之前，T64还有一个高效的算法帮我数路径条数，但是通道建成之后，他还有办法吗？ 对，T64手忙脚乱，根本数不清有多少条路径。于是他找到了你。
Input Format
第一行为三个正整数N，M，K（2 ≤ K ≤ N），代表有n间寝室，m条边连接它们，m= n-1意味着“情报遁道”未被修好；m=n意味着“情报通道”已被修好），以及题目描述中的K。
接下来m行，每行两个正整数z，y，代表第x间寝室与第y间寝室之间有一条双向边。
Output Format
仅包含一个整数，代表经过至少K间寝室的路径条数。
Sample Input
5 5 2
1 3
2 4
3 5
4 1
5 2
Sample Output
20
解析
如果不考虑那条情报通道，那就是一个点分治模板题，没什么难度，并且可以拿到(50)分的高分。
现在变成基环树上的路径统计，好像不能直接点分治了。那就考虑一下基环树的套路，一般来说，基环树问题可以有两种方法化简：(1.) 强制拆一条边，按照树的方式计算，然后计算强制加入这条边的贡献。(2.) 每次枚举一条环上的边拆掉，然后分别计算贡献，最后合并答案。
对于这道题，其实两种方法都可以使用，不过显然使用第一种会比较简单。
我们可以先找到基环树的环，然后把环上的一条边断开，对整棵树进行点分治，那么没有统计的贡献就只剩下了包含这条边的路径。
考虑如何统计这些路径，可以枚举环上的点，和点分治计算贡献一样用树状数组把半条路径的贡献存起来，然后找另外半条路径的时候计算贡献即可，使这两边的路径中间恰好有我们刚刚删去的那条边，这样就强制把这条边选进去了。
细节有点多，码量有点大，多看看是不是有点算重复了。
(Code:)
#include <bits/stdc++.h>
using namespace std;
const int N = 100020 , INF = 0x3f3f3f3f;
inline int read(void)
{
int x = 0 , w = 0; char ch = ' ';
while ( !isdigit(ch) ) w |= ch == '-' , ch = getchar();
while ( isdigit(ch) ) x = x * 10 + ch - 48 , ch = getchar();
return w ? -x : x;
}
struct edge { int ver,next; } e[2*N];
int n,m,k,t,Head[N],fa[N],vis[N],loop[N],cnt,num;
int Max[N],size[N],dis[N],flag[N],root,tot,ban;
long long ans;
struct BinaryIndexedTree
{
int c[N];
inline int lowbit(int x) { return x & (-x); }
inline void insert(int p,int v) { for (;p<=n;p+=lowbit(p)) c[p] += v; }
inline int query(int p)
{
if ( p <= 0 ) return 0;
int res = 0;
for (;p;p-=lowbit(p)) res += c[p];
return res;
}
} Tree;
inline void insert(int x,int y)
{
e[++t] = (edge){y,Head[x]} , Head[x] = t;
e[++t] = (edge){x,Head[y]} , Head[y] = t;
}
inline void input(void)
{
t = 1;
n = read() , m = read() , k = read();
for (int i=1;i<=m;i++)
insert( read() , read() );
}
inline void dp(int x,int f)
{
size[x] = 1 , Max[x] = 0;
for (int i=Head[x];i;i=e[i].next)
{
int y = e[i].ver;
if ( y == f || flag[y] ) continue;
if ( i == ban || (i^1) == ban ) continue;
dp( y , x );
size[x] += size[y];
Max[x] = max( Max[x] , size[y] );
}
Max[x] = max( Max[x] , tot - size[x] );
if ( Max[x] < Max[root] ) root = x;
}
inline void dfs(int x,int f)
{
for (int i=Head[x];i;i=e[i].next)
{
int y = e[i].ver;
if ( y == f || flag[y] ) continue;
if ( i == ban || (i^1) == ban ) continue;
dis[y] = dis[x] + 1;
dfs( y , x );
}
}
inline void calc(int x,int f)
{
ans += Tree.query( n ) - Tree.query( k - dis[x] );
for (int i=Head[x];i;i=e[i].next)
{
int y = e[i].ver;
if ( y == f || flag[y] ) continue;
if ( i == ban || (i^1) == ban ) continue;
calc( y , x );
}
}
inline void update(int x,int f,int v)
{
Tree.insert( dis[x] , v );
for (int i=Head[x];i;i=e[i].next)
{
int y = e[i].ver;
if ( y == f || flag[y] ) continue;
if ( i == ban || (i^1) == ban ) continue;
update( y , x , v );
}
}
inline void divide(int x)
{
flag[x] = true , dis[x] = 1;
dfs( x , 0 );
Tree.insert( 1 , 1 );
for (int i=Head[x];i;i=e[i].next)
{
int y = e[i].ver;
if ( flag[y] ) continue;
if ( i == ban || (i^1) == ban ) continue;
calc( y , x ) , update( y , x , 1 );
}
for (int i=Head[x];i;i=e[i].next)
{
int y = e[i].ver;
if ( flag[y] ) continue;
if ( i == ban || (i^1) == ban ) continue;
update( y , x , -1 );
}
Tree.insert( 1 , -1 );
for (int i=Head[x];i;i=e[i].next)
{
int y = e[i].ver;
if ( flag[y] ) continue;
if ( i == ban || (i^1) == ban ) continue;
tot = size[y] , root = 0;
dp( y , 0 );
divide( root );
}
}
inline void findloop(int x)
{
vis[x] = ++num;
for (int i=Head[x];i;i=e[i].next)
{
int y = e[i].ver;
if ( y == fa[x] ) continue;
if ( vis[y] )
{
if ( vis[y] < vis[x] ) continue;
loop[++cnt] = y;
for (;y!=x;y=fa[y]) loop[++cnt] = fa[y];
}
else fa[y] = x , findloop( y );
}
}
inline void update_(int x,int f,int op,int v)
{
Tree.insert( dis[x] + v , op );
for (int i=Head[x];i;i=e[i].next)
{
int y = e[i].ver;
if ( y == f || flag[y] ) continue;
update_( y , x , op , v );
}
}
inline void calc_(int x,int f,int v)
{
ans += Tree.query( n ) - Tree.query( k - dis[x] - v - 1 );
for (int i=Head[x];i;i=e[i].next)
{
int y = e[i].ver;
if ( y == f || flag[y] ) continue;
calc_( y , x , v );
}
}
inline void solve(void)
{
for (int i=Head[loop[1]];i;i=e[i].next)
if ( e[i].ver == loop[cnt] )
{ ban = i; break; }
root = 0 , tot = n , Max[0] = INF;
dp( 1 , 0 ) , divide( root );
ban = 0;
memset( flag , 0 , sizeof flag );
for (int i=1;i<=cnt;i++)
flag[loop[i]] = true;
for (int i=1;i<=cnt;i++)
{
dis[loop[i]] = 1;
dfs( loop[i] , 0 );
}
for (int i=1;i<=cnt;i++)
update_( loop[i] , 0 , 1 , i );
for (int i=cnt;i>=1;i--)
update_( loop[i] , 0 , -1 , i ),
calc_( loop[i] , 0 , cnt - i - 1 );
}
int main(void)
{
input();
if ( m == n-1 )
{
root = 0 , tot = n , Max[0] = INF;
dp( 1 , 0 );
divide( root );
}
else findloop(1) , solve();
printf("%lld
",ans);
return 0;
}
<后记>