[Luogu 1967] NOIP2013 货车运输
[Luogu 1967] NOIP2013 货车运输
一年多前令我十分头大的老题终于可以随手切掉了…
然而我这码风又变毒瘤了，我也很绝望。
看着一年前不带类不加空格不空行的清纯码风啊，时光也好像回去了一样。//其实一年前我在这题上试过写类来着，结果，当然是写挂了啊。
众人：别废话了，赶紧讲题！
Capella：好，好…
对于每两个点之间的路径，我们希望路上的最小限重尽可能大，以确保运输更多的货物。所以，我们总是会选择限重尽可能大的路去走。
于是对原图（的每一个连通块）求最大生成树，将问题转化为树上问题。两个点间的的路径可通过求 LCA（最近公共祖先）得到。
LCA 考虑倍增算法（树剖不想写了），使用两个 Sparse Table（通称 ST 表），一个存树上路径，一个存树上限重最小值。
讲具体些，f[i][j] 记录编号为 i 的点向上走 \(2^j\) 步到达的点，g[i][j]记录从 i 到 f[i][j] 这段路径中的最小限重。
递推预处理，然后在线询问就好。
如果你刚才用了 Kruskal 求 MST，那么 Kruskal 算法过程中用过的并查集不要扔，洗干净裹上面粉，蛋液，面包糠，下锅炸至两面金黄后捞出，隔壁家的熊孩子都馋哭了。对于每一组询问 (x, y)，看一眼两个点是否属于同一并查集，不是就直接 -1。
如果你用了 Prim，记得跑的时候记一下连通块，用于判断询问的两个点是否连通。
跑就行了，求路径上最小限重。
上代码
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
const int MAXN=100010, MAXM=500010;
int n, m, q;
struct Edge
{
int u, v, w;
void Read(void)
{
scanf("%d %d %d", &u, &v, &w);
}
bool operator <(const Edge &rhs) const
{
return w>rhs.w;
}
}s[MAXM];
struct Graph
{
int *depth;
struct Edge
{
int to, w;
Edge *next;
Edge(int to, int w, Edge* next): to(to), w(w), next(next){}
~Edge(void)
{
if(next!=nullptr)
delete next;
}
}**head;
Graph(int n): depth(new int[n+1]), head(new Edge*[n+1])
{
memset(depth, 0, (n<<2)+4);
for(int i=1; i<=n; ++i)
head[i]=nullptr;
}
~Graph(void)
{
delete[] depth;
for(int i=1; i<=n; ++i)
delete head[i];
delete[] head;
}
void AddEdges(int u, int v, int w)
{
head[u]=new Edge(v, w, head[u]);
head[v]=new Edge(u, w, head[v]);
}
}*G;
class UFS
{
private:
int *f;
public:
UFS(int n): f(new int[n+1])
{
for(int i=1; i<=n; ++i)
f[i]=i;
}
~UFS(void)
{
delete[] f;
}
int Find(int x)
{
return x==f[x] ? x : f[x]=Find(f[x]);
}
bool Merge(int x, int y)
{
int a=Find(x), b=Find(y);
if(a==b)
return false;
f[b]=a;
return true;
}
}*S;
class SparseTable
{
private:
int N, **f, **g;
void DFS(int u, int k)
{
G->depth[u]=k;
int v;
for(auto i=G->head[u]; i!=nullptr; i=i->next)
if(!G->depth[v=i->to])
{
f[v][0]=u;
g[v][0]=i->w;
DFS(v, k+1);
}
}
public:
SparseTable(int n): N(log2(n)), f(new int*[n+1]), g(new int*[n+1])
{
for(int i=1; i<=n; ++i)
{
f[i]=new int[N];
g[i]=new int[N];
}
for(int i=1; i<=n; ++i)
if(!G->depth[i])
{
f[i][0]=i;
g[i][0]=INT_MAX;
DFS(i, 1);
}
for(int j=1; j<=N; ++j)
for(int i=1; i<=n; ++i)
{
f[i][j]=f[f[i][j-1]][j-1];
g[i][j]=std::min(g[i][j-1], g[f[i][j-1]][j-1]);
}
}
~SparseTable(void)
{
for(int i=1; i<=n; ++i)
{
delete[] f[i];
delete[] g[i];
}
delete[] f;
delete[] g;
}
int LCA(int x, int y)
{
if(S->Find(x)^S->Find(y))
return -1;
int ans=INT_MAX;
if(G->depth[x]<G->depth[y])
std::swap(x, y);
for(int i=N; i>=0; --i)
if(G->depth[f[x][i]]>=G->depth[y])
{
ans=std::min(ans, g[x][i]);
x=f[x][i];
}
if(x==y)
return ans;
for(int i=N; i>=0; --i)
if(f[x][i]^f[y][i])
{
ans=std::min(ans, std::min(g[x][i], g[y][i]));
x=f[x][i];
y=f[y][i];
}
return ans=std::min(ans, std::min(g[x][0], g[y][0]));
}
}*ST;
void Kruskal(void)
{
std::sort(s+1, s+m+1);
S=new UFS(n);
G=new Graph(n);
for(int i=1; i<=m; ++i)
if(S->Merge(s[i].u, s[i].v))
G->AddEdges(s[i].u, s[i].v, s[i].w);
}
int main(void)
{
scanf("%d %d", &n, &m);
for(int i=1; i<=m; ++i)
s[i].Read();
Kruskal();
ST=new SparseTable(n);
scanf("%d", &q);
for(int i=1, x, y; i<=q; ++i)
{
scanf("%d %d", &x, &y);
printf("%d\n", ST->LCA(x, y));
}
delete S;
delete G;
delete ST;
return 0;
}
谢谢阅读
