HDU4812-D Tree-树分治

题目描述

There is a skyscraping tree standing on the playground of Nanjing University of Science and Technology. On each branch of the tree is an integer (The tree can be treated as a connected graph with N vertices, while each branch can be treated as a vertex). Today the students under the tree are considering a problem: Can we find such a chain on the tree so that the multiplication of all integers on the chain (mod 10 6 + 3) equals to K?
Can you help them in solving this problem?
Input
There are several test cases, please process till EOF.
Each test case starts with a line containing two integers N(1 <= N <= 10 5) and K(0 <=K < 10 6 + 3). The following line contains n numbers v i(1 <= v i < 10 6 + 3), where vi indicates the integer on vertex i. Then follows N - 1 lines. Each line contains two integers x and y, representing an undirected edge between vertex x and vertex y.
Output
For each test case, print a single line containing two integers a and b (where a < b), representing the two endpoints of the chain. If multiply solutions exist, please print the lexicographically smallest one. In case no solution exists, print “No solution”(without quotes) instead.
For more information, please refer to the Sample Output below.
Sample Input
5 60
2 5 2 3 3
1 2
1 3
2 4
2 5
5 2
2 5 2 3 3
1 2
1 3
2 4
2 5
Sample Output
3 4
No solution
Hint
1. “please print the lexicographically smallest one.”是指: 先按照第一个数字的大小进行比较，若第一个数字大小相同，则按照第二个数字大小进行比较，依次类推。
2. 若出现栈溢出，推荐使用C++语言提交，并通过以下方式扩栈：
#pragma comment(linker,"/STACK:102400000,102400000")

题目分析

很清晰应该使用树分治，但是不同于一般树分治的是这里要求我们记录两个点的位置。这就意味这不能直接套之前的模板，而必须做出一些变通。

首先，求重心、进行分治应该是没有变化的，变的是对每个重心进行处理的部分。我们要把握住问题的难点在于如果记录答案的话，我们如何记录两个端点以及如何处理记录以后去掉子树中重复的操作。

一般的树分治先将以重心为根的路径全部遍历一遍，将所有符合要求的答案保存，然后再在相同参数下遍历子树，将子树中满足条件的（说明刚才重复计算的部分）去掉。最后得到的就是答案。然而我们这里需要记录答案，朴素的想法就是同样将所有符合的都记录下来（同时记录两个端点），然后再在子树中将这些答案删除。可是这种删除将会非常耗费时间，我们必须在那个暂时保存答案的集合里面找到同一对数，最快也得O(nlogn),更何况我们这个操作要进行很多次。肯定会超时，所以我们必须换一个思路思考这个问题。

必须要删除的核心关键在于我们在第一次访问重心的时候没有办法判断是否在同一个子树上，所以只能先加上再减去。有没有方法能够避免计算同一个子树上的答案呢？

我原本的想法是每次访问重心得到其他点到重心的距离前先访问一次重心进行染色，将每个子树染成不同的颜色，然后再处理数据的时候再判断是否在同一个子树上来判断是否是有效数据。可是题目要求记录的是乘积等于k的字典序最小的一对端点。我们这样做就必须记录下所有的端点，答案可能很多，先不说存的下不，仅仅是记录的操作估计都会超时。

不得已我上网看了以下其他人是怎么做的。他们的做法很巧妙，也让我对树分治有了更深刻的理解。

首先，我们必须扭转将所有路径的答案都记录下来再进行处理的观念。这样对于只是求路径个数的可能没有什么问题，但是对于这种需要具体得到两个端点的情况会超时。所以我们必须可以在某一端点处直接判断是否存在有其他端点可以和它凑成答案。为了达到这个效果我们用一个数组T记录以当前重心为根的情况下各个端点距离重心距离x所对应的端点为T[x]，因为最后需要的是字典序最小的，所以我们保存所有T[x]中最小的就可以。然后对于每一个端点我们得到它的距离Dis[i]以后判断是否有其他端点到树根的距离为x使得Dis[i]*x==k，为了快速得到这个x，我们需要预处理以下乘法逆元Rev[]。则和端点i对应的端点就应该是T[Rev[Dis[x]]]。如果i和对应的端点都存在则和当前答案比较，确定是否更新答案。

如果不清楚什么是乘法逆元可以看一下我的这篇博客：逆元

可是这算是解决了如何存储两个端点的问题。但是如何消除同一个子树中的端点的影响呢？我们的做法是不再像之前一样一下遍历所有的节点了，而是一个子树一个子树的遍历。并且对T数组的更新放在对答案的判断之后。这样做的原因是访问一个子树的时候，他们这个字数上的信息没有被更新到T数组中，因此T数组中保存的就是前面的子树的信息，也就不会出现访问到同一个子树的情况啦。

在每次开始分治，我们的T数组应该是互相没有联系的，因此需要进行清空

同时我们用一个栈来保存访问子树中所有节点的信息，先更新答案后再更新T数组。

还需要注意一点的是我们的信息是保存在节点上的，因此根节点的信息先不要传递，在更新答案的时候再算上就可以啦。

AC代码

#pragma comment(linker,"/STACK:102400000,102400000")
#include<iostream>
#include<cstring>
#include<cstdio>
#include<climits>
#include<algorithm>
#include<ctime>
#include<cstdlib>
#include<queue>
#include<set>
#include<map>
#include<cmath>#define RG register
#define IL inlineusing namespace std;
typedef long long ll;
const int MAXN=2e5+5;
const int MOD=1e6+3;
struct edge
{int to,last;
}Edge[MAXN<<2]; int Last[MAXN],tot;
int n,kk,SonNum[MAXN],MaxNum[MAXN],Vis[MAXN];
int root,rootx,dlen,ss,len;
ll Dis[MAXN],Rev[MOD+5],Num[MAXN];
int Stack[MAXN],T[MOD+5]; int top;
int ansl,ansr;IL int getint()
{int x=0,sign=1; char c=getchar();while(c<'0' || c>'9'){if(c=='-') sign=-1; c=getchar();}while(c>='0' && c<='9'){x=(x<<1)+(x<<3)+c-'0'; c=getchar();}return x*sign;
}
IL ll getll()
{ll x=0,sign=1; char c=getchar();while(c<'0' || c>'9'){if(c=='-') sign=-1; c=getchar();}while(c>='0' && c<='9'){x=(x<<1)+(x<<3)+c-'0'; c=getchar();}return x*sign;
}IL void Init()
{for(int i=0;i<=n;++i) Last[i]=0,Vis[i]=false;tot=0; ansl=ansr=INT_MAX;
}IL void AddEdge(int u,int v)
{Edge[++tot].to=v; Edge[tot].last=Last[u]; Last[u]=tot;
}IL void Read()
{for(RG int i=1;i<=n;++i) Num[i]=getll();int u,v;for(RG int i=1;i<n;i++){u=getint(); v=getint();AddEdge(u,v); AddEdge(v,u);}
}void GetRoot(int x,int father)
{int v;SonNum[x]=1; MaxNum[x]=1;for(int i=Last[x];i;i=Edge[i].last){v=Edge[i].to; if(v==father || Vis[v]) continue;GetRoot(v,x);SonNum[x]+=SonNum[v];if(SonNum[v]>MaxNum[x]) MaxNum[x]=SonNum[x];}MaxNum[x]=max(MaxNum[x],ss-SonNum[x]);if(rootx>MaxNum[x]) root=x,rootx=MaxNum[x];
}void GetDis(int x,int father,ll now)
{ll t=now*Num[x]%MOD;Dis[x]=t; Stack[top++]=x;int v;for(RG int i=Last[x];i;i=Edge[i].last){v=Edge[i].to; if(v==father|| Vis[v]) continue;GetDis(v,x,t);}
}void Update(ll x,ll y,int z)
{int tmp=T[Rev[x*y%MOD]*kk%MOD];if(!tmp) return;if(z>tmp) swap(z,tmp);if(z<ansl || z==ansl&&tmp<ansr) ansl=z,ansr=tmp;
}void Solve(int x)
{//memset(Dis,0,sizeof(Dis));int v;T[1]=x;Vis[x]=true;for(RG int i=Last[x];i;i=Edge[i].last){dlen=0; top=0;v=Edge[i].to; if(Vis[v]) continue;GetDis(v,x,1);for(RG int j=0;j<top;++j) Update(Num[x],Dis[Stack[j]],Stack[j]);for(RG int j=0;j<top;++j) if(T[Dis[Stack[j]]]==0 || T[Dis[Stack[j]]]>Stack[j]) T[Dis[Stack[j]]]=Stack[j];}for(int i=Last[x];i;i=Edge[i].last){dlen=0; top=0;v=Edge[i].to; if(Vis[v]) continue;GetDis(v,x,1);for(int j=0;j<top;++j) T[Dis[Stack[j]]]=0;}for(int i=Last[x];i;i=Edge[i].last){v=Edge[i].to; if(Vis[v]) continue;//ans-=Count(v,Deal(x,0));ss=SonNum[v]; rootx=INT_MAX; root=0;GetRoot(v,x);Solve(root);}
}IL void Work()
{rootx=INT_MAX; ss=n; root=0; GetRoot(1,0); Solve(root);
}IL void Write()
{if(ansl==INT_MAX && ansr==INT_MAX){printf("No solution\n");}else{printf("%d %d\n",ansl,ansr);}
}IL void Pre()
{Rev[1]=1;for(ll i=2;i<MOD;++i)Rev[i]=(MOD-MOD/i)*Rev[MOD%i]%MOD;
}int main()
{Pre();while(~scanf("%d%d",&n,&kk)){Init();Read();Work();Write();}return 0;
}

经验总结

对于一个问题首先要抽象出来需要用那种算法进行解决。局部的处理常常需要其他算法和数据结构的优化。尽可能不适用map和set等，能用数组还是尽量用数组。对数组的初始化也需要讲究技巧，不能简单使用一个memset，这种做法很容易超时。