参考:
1. 郭华阳 - 算
2. http://www.cnblogs.com/lazycal/archive/2012/08/11/2633486.html
3. 代码来源yejinru
题意:
有一棵树, 按照顺序给出每条边, 再给出若干对点, 这两点之间的唯一的路( Simple path )上边权加1. 当所有对点处理完后, 按照边的输入顺序输出每条边的权.
思路:
LCA问题.
最近公共祖先(Least Common Ancestors)LCA简介：对于有根树T的两个结点u、v，最近公共祖先LCA(T,u,v)表示一个结点x，满足x是u、v的祖先且x的深度尽可能大。另一种理解方式是把T理解为一个无向无环图，而LCA(T,u,v)即u到v的最短路上深度最小的点。——百度百科
问题等效于: 若点为( x, y ), 且有 LCA( x, y ) = z. 则 x, z y, z 之间的边权均+1. 区间+1可以用差分数列的思想, 令dis[ x ] 为 x 点与其子节点之间的差值. x 点对应连接 x 和其父节点的边.
解法一:
Tarjan算法,离线操作.
建树的方法除了用vector以外, 还可以换为链式前向星. 不过还是vector顺手些~
p.s. 还是 [ 理论: 国家集训队论文 / ppt + 实践: 学长的模板 ] 这样的tempo比较靠谱~
/*
在树的任意两点所在的所有树的边权加一，输出最后所有的边权
LCA。我们可以离线操作，把所有的询问直接求出LCA，然后用数组
dis[x] ++ , dis[y]++,
dis[LCA(x,y)] -= 2
最后DFS统计一下答案
*/
#include <set>
#include <map>
#include <list>
#include <cmath>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define debug puts("here")
#define rep(i,n) for(int i=0;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define REP(i,a,b) for(int i=a;i<=b;i++)
#define foreach(i,vec) for(unsigned i=0;i<vec.size();i++)
#define pb push_back
#define RD(n) scanf("%d",&n)
#define RD2(x,y) scanf("%d%d",&x,&y)
#define RD3(x,y,z) scanf("%d%d%d",&x,&y,&z)
#define RD4(x,y,z,w) scanf("%d%d%d%d",&x,&y,&z,&w)
#define All(vec) vec.begin(),vec.end()
#define MP make_pair
#define PII pair<int,int>
#define PQ priority_queue
#define cmax(x,y) x = max(x,y)
#define cmin(x,y) x = min(x,y)
#define fir first
#define sec second
/******** program ********************/
const int MAXN = 2e5+5;
vector< PII > edge[MAXN];
vector< PII > ask[MAXN];
int fa[MAXN];
bool use[MAXN];
int pa[MAXN];
int n,m;
int dis[MAXN];
int a[MAXN],b[MAXN];
int ans[MAXN];
int find_set(int x){///并查集找父节点路径压缩
if(fa[x]!=x)
fa[x] = find_set(fa[x]);
return fa[x];
}
/*********Tarjan算法的核心思想*********/
void lca(int x,int f){
//cout<<"x = "<<x<<endl;
use[x] = true;///已经遍历
fa[x] = x;///该节点插入并查集,并且自己为一个独立的集合
foreach(i,ask[x]){///遍历有关节点x的所有询问
int y = ask[x][i].first;///目标节点
int id = ask[x][i].second;///输入的顺序
//cout<<"dsadsa = "<<x<<" "<<y<<" "<<id<<endl;
if(use[y])
pa[id] = find_set(y);///如果已经遍历,那么答案就是它的父节点
}
foreach(i,edge[x]){///遍历所有儿子
int y = edge[x][i].first;
//cout<<"y = "<<y<<endl;
if(use[y])continue;
lca(y,x);///如果当前正在访问该子树的根,那么此前已访问过的节点的父节点必然是
///从根节点到该节点的唯一路上(*).这本身也是一个dfs
fa[y] = x;///如果已经回溯,即完成了上一条语句对y节点子树的遍历,
///退出之后将y节点的父节点设为x,也就保证了这一步退出之后(*)条件仍然成立.
}
}
void dfs(int x,int f){
foreach(i,edge[x]){
int y = edge[x][i].first;
if(y==f)continue;
dfs(y,x);
int id = edge[x][i].second;
dis[x] += dis[y];///类似于差分数列的思想
ans[id] = dis[y];///从叶子节点向根统计结果
}
}
int main(){
//#ifndef ONLINE_JUDGE
// freopen("sum.in","r",stdin);
//freopen("sum.out","w",stdout);
//#endif
while(cin>>n){
int x,y;
rep(i,MAXN){//清零
edge[i].clear();
ask[i].clear();
}
memset(use,false,sizeof(use));//清零初始化
REP(i,2,n){
RD2(x,y);
edge[x].pb( MP(y,i) );
edge[y].pb( MP(x,i) );
}
RD(m);
rep1(i,m){
RD2(x,y);
a[i] = x;//第i条路的两端点
b[i] = y;
ask[x].pb( MP(y,i) );//注意ask也是双向插入的
ask[y].pb( MP(x,i) );
}
lca(1,0);
memset(dis,0,sizeof(dis));
rep1(i,m){
x = a[i];
y = b[i];
dis[x] ++;///类似于差分数列的思想
dis[y] ++;
dis[ pa[i] ] -= 2;///保证增量向上至多只影响到lca),lca以上的路不受下面子树影响
//cout<<x<<" "<<y<<" "<<pa[i]<<endl;
}
dfs(1,0);
REP(i,2,n)
printf("%d ",ans[i]);
puts("");
}
return 0;
}
自己敲一遍:
#include <cstdio>
#include <vector>
#include <cstring>
#include <utility>
using namespace std;
const int MAXN = 2e5+5;
int n,m,x,y;
vector<pair<int, int> > query[MAXN],edge[MAXN<<1];
int a[MAXN],b[MAXN],dif[MAXN],ans[MAXN],lca[MAXN],fa[MAXN];
bool vis[MAXN];
int find_set(int x)
{
if(fa[x]!=x)
fa[x] = find_set(fa[x]);
return fa[x];
}
void LCA_Tarjan(int u)
{
vis[u] = true;
fa[u] = u;
for(size_t i=0;i<query[u].size();i++)
{
int v = query[u][i].first;
int id = query[u][i].second;
if(vis[v])
lca[id] = find_set(v);///注意这里的id是询问的id,恰好对应一对节点
}
for(size_t i=0;i<edge[u].size();i++)
{
int v = edge[u][i].first;
if(vis[v]) continue;
LCA_Tarjan(v);
fa[v] = u;
}
}
void solve()
{
for(int i=0;i<m;i++)
{
x = a[i];
y = b[i];
dif[x]++; dif[y]++;///差分数列
dif[lca[i]] -= 2;
}
}
void dfs(int u, int f)
{
for(size_t i=0;i<edge[u].size();i++)
{
int v = edge[u][i].first;
if(v==f) continue;
dfs(v, u);
int id = edge[u][i].second;
dif[u] += dif[v];
ans[id] = dif[v];///这里的id是边的序号
}
}
int main()
{
scanf("%d",&n);
for(int i=1;i<n;i++)
{
scanf("%d %d",&x,&y);
edge[x].push_back(make_pair(y,i));
edge[y].push_back(make_pair(x,i));
}
scanf("%d",&m);
for(int i=0;i<m;i++)
{
scanf("%d %d",&x,&y);
a[i] = x;
b[i] = y;///记下第i个询问对应的两端点
query[x].push_back(make_pair(y,i));
query[y].push_back(make_pair(x,i));
}
//选谁作为根是无所谓的,不妨就选1号为根.
LCA_Tarjan(1);
solve();
dfs(1,0);
for(int i=1;i<n;i++)
printf("%d%c",ans[i],i==n-1?'\n':' ');
}
解法二:
ST算法( Sparse Table ). ST算法是解决RMQ问题的一种在线算法.
RMQ (Range Minimum/Maximum Query)问题是指：对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j<=n)，返回数列A中下标在i,j里的最小(大）值，也就是说，RMQ问题是指求区间最值的问题。——百度百科
LCA与RMQ的相互转化
首先说明LCA问题与RMQ问题为何可以相互转化.
/************分割线************/
ST算法
ST算法是基于倍增思想设计的O(NlogN) - O(1)在线算法.
简单来说:
利用 dp 预处理出每一段的最值，对于每个询问，只要O(1)的时间便能得出答案。
dp 如下：dp[ i ][ j ]表示从第i个位置开始的 2^j 个数中的最小值。转移方程如下：
dp[i][j]=min(dp[i][j-1],dp[i+1<<(j-1)][j-1])
这样，对于每个查询 x, y ( x < y )（在第 x 个位置到第 y 个位置的最值），答案就是
min(dp[x][j],dp[y-(1<<j)+1][j])(其中j是(int)log2(y-x+1))
∵[x,x+(1<<j)]与[y-(1<<j),y]都是[x,y]的子区间且[x,x+1<<j]∪[y-1<<j]=[x,y]。
至此RMQ问题就解决了，时间复杂度为O( nlogn )+O(1)* q(其中 q 为询问数量)
求解LCA
求LCA的其中一种算法便是转换成RMQ，利用ST算法求解。
具体做法如下：将这棵树用深度优先遍历，每次遍历一个点（包括回溯）都添加进数组里面。找到所询问的点第一次出现的位置，两个位置所夹的点中深度最小的即为所求。
/*
在树的任意两点所在的所有树的边权加一，输出最后所有的边权
LCA。我们可以在线操作，用数组
dis[x] ++ , dis[y]++,
dis[LCA(x,y)] -= 2
最后DFS统计一下答案
*/
#include <set>
#include <map>
#include <list>
#include <cmath>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define debug puts("here")
#define rep(i,n) for(int i=0;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define REP(i,a,b) for(int i=a;i<=b;i++)
#define foreach(i,vec) for(unsigned i=0;i<vec.size();i++)
#define pb push_back
#define RD(n) scanf("%d",&n)
#define RD2(x,y) scanf("%d%d",&x,&y)
#define RD3(x,y,z) scanf("%d%d%d",&x,&y,&z)
#define RD4(x,y,z,w) scanf("%d%d%d%d",&x,&y,&z,&w)
#define All(vec) vec.begin(),vec.end()
#define MP make_pair
#define PII pair<int,int>
#define PQ priority_queue
#define cmax(x,y) x = max(x,y)
#define cmin(x,y) x = min(x,y)
#define fir first
#define sec second
/******** program ********************/
const int MAXN = 200005;
int n;
vector< PII > edge[MAXN];
int dp[MAXN][20];
int dis[MAXN];
int depth;
int b[MAXN],bn; //深度序列
int f[MAXN]; //对应深度序列中的结点编号
int p[MAXN]; //结点在深度序列中的首位置
int ans[MAXN];
void dfs(int x,int fa){
int tmp = ++ depth;
///没有必要保证兄弟的深度相等,
///只要满足父节点深度小于儿子即可.
///而且是不能的!如果兄弟深度相等的话,
///就无法依据最近公共祖先的深度确定是哪一个节点了!
///这样令兄弟的深度有所不同就使得
///找到的"最小深度"可以直接对应节点
///(每个节点的深度都是不同的)
b[++bn] = tmp;
f[tmp] = x;
p[x] = bn;
foreach(i,edge[x]){
int y = edge[x][i].first;
if (y==fa) continue;
dfs(y,x);
b[++bn] = tmp;
}
}
void rmq_init(int n){ //以深度序列做rmq
rep1(i,n)
dp[i][0]=b[i];
int m = floor(log(n*1.0)/log(2.0));
///向下取整,因为向上取整并没有完整的2^m长度的区间
rep1(j,m)
for (int i=1; i<=n-(1<<j)+1; i++)///非递归的方式
dp[i][j] = min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
}
int rmq(int l,int r){
int k = floor(log((r-l+1)*1.0)/log(2.0));
return min( dp[l][k] , dp[r-(1<<k)+1][k] );
}
int lca(int a,int b){
if (p[a]>p[b])
swap(a,b);
return f[ rmq(p[a],p[b]) ];
}
void qq(int x,int f){///dfs求ans
foreach(i,edge[x]){
int y = edge[x][i].first;
if(y==f)continue;
qq(y,x);
int id = edge[x][i].second;
dis[x] += dis[y];
ans[id] = dis[y];
}
}
int main(){
while(cin>>n){
rep(i,MAXN)
edge[i].clear();
depth = bn = 0;
int x,y;
REP(i,2,n){
RD2(x,y);
edge[x].pb( MP(y,i) );
edge[y].pb( MP(x,i) );
}
dfs(1,0);
rmq_init(bn);
int m;
RD(m);
memset(dis,0,sizeof(dis));
while(m--){
RD2(x,y);
dis[x] ++;
dis[y] ++;
dis[ lca(x,y) ] -= 2;
}///和离线做法的差别就在于:
///可以直接求出lca而不需要在遍历树的过程中依据相同的端点来求
qq(1,0);
REP(i,2,n)
printf("%d ",ans[i]);
puts("");
}
return 0;
}
自己敲一遍:
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <vector>
#include <utility>
using namespace std;
const int MAXN = 1e5+5;
vector< pair<int, int> > edge[MAXN];
int n,depth;
int dfs[MAXN<<1],dn;///dfs序深度序列.一个点会dfs多次,总次数为2*n-1次
int DtoN[MAXN];///深度对应的节点编号
int pos[MAXN];///节点第一次出现在dfs序中的位置
int dp[MAXN<<1][20];
int dis[MAXN],ans[MAXN];
void build_dfs_series(int s,int f)
{
dfs[++dn] = ++depth;
int tmp = depth;
DtoN[depth] = s;
pos[s] = dn;
for(int i=0;i<edge[s].size();i++)
{
int y = edge[s][i].first;
if(y==f) continue;
build_dfs_series(y, s);
dfs[++dn] = tmp;
}
}
void pre_rmq()
{
for(int i=1;i<=dn;i++)
dp[i][0] = dfs[i];
int m = floor(log(dn*1.0)/log(2.0));
for(int j=1;j<=m;j++)
{
for(int i=1;i<=dn+1-(1<<j);i++)
dp[i][j] = min(dp[i][j-1], dp[i+(1<<(j-1))][j-1]);
}
}
int rmq(int l, int r)
{
int j = floor(log((r-l+1)*1.0)/log(2.0));
return min(dp[l][j], dp[r-(1<<j)+1][j]);
}
int lca(int x, int y)
{
int l = pos[x], r = pos[y];
if(l>r)
swap(l, r);
return DtoN[ rmq(l,r) ];
}
void cal(int s, int f)
{
for(int i=0;i<edge[s].size();i++)
{
int y = edge[s][i].first;
if(y==f) continue;
int id = edge[s][i].second;
cal(y, s);
dis[s] += dis[y];
ans[id] = dis[y];///每条边对应它的靠近叶子的节点
}
}
int main()
{
scanf("%d",&n);
for(int i=1,u,v;i<n;i++)
{
scanf("%d %d",&u,&v);
edge[u].push_back( make_pair(v, i) );
edge[v].push_back( make_pair(u, i) );
}
depth = 0;
dn = 0;
build_dfs_series(1, 0);
pre_rmq();
int m,x,y;
scanf("%d",&m);
for(int i=0;i<m;i++)
{
scanf("%d %d",&x,&y);
dis[x]++;dis[y]++;
dis[lca(x,y)] -= 2;
}
cal(1, 0);
for(int i=1;i<n;i++)
printf("%d%c",ans[i],(i==n-1)?'\n':' ');
}
(有点难记啊...)