【网络流+倍增/树链剖分优化建边】CF786E ALT

【题目】
CF
$n$个点的树，有$m$个人走$m$条路径，一个人开心当且仅当自己有一只狗或者路径上的每条边有一只狗，问最少花费多少只狗，并输出方案。$n\le 2\times 10^4,m\le 10^4$

【解题思路】
这是一个经典的最小割模型：从$S$连向每个人，容量为$1$，每条边连向$T$，容量为$1$，每个人向对应路径上所有边连边，容量为$\text{INF}$。

这样连边数比较多，用倍增优化建边即可，具体可以参见代码。

总的边数和点数级别都是$O(m\log n)$的。

关于输出方案，只需要在残量网络上从$S$进行$dfs$即可，具体来说，若一个代表人的点$dfs$时没有被访问到，则说明给它分配了一只狗，若一个代表边的点没有被访问到，则说明这条边上有一只狗。

开数组不要吝啬，越界问题可能会花费很长时间去调试- -。
【参考代码】

#include<bits/stdc++.h>
#define pb push_back
using namespace std;

const int N=4e5+10,M=5e6+10,INF=0x3f3f3f3f;
int n,m,cnt,id[N][16],fc[20];

namespace IO
{
	int read()
	{
		int ret=0;char c=getchar();
		while(!isdigit(c)) c=getchar();
		while(isdigit(c)) ret=ret*10+(c^48),c=getchar();
		return ret;
	}
	void write(int x){if(x>9)write(x/10);putchar(x%10^48);}
	void writeln(int x){write(x);putchar('\n');}
	void writesp(int x){write(x);putchar(' ');}
}
using namespace IO;

namespace Flow
{
	int tot,S,T,head[N],dis[N],vis[N];
	vector<int>ans1,ans2;
	queue<int>q;
	struct Tway{int v,w,nex;}e[M<<1];
	void add(int u,int v,int w)
	{
		e[++tot]=(Tway){v,w,head[u]};head[u]=tot;
		e[++tot]=(Tway){u,0,head[v]};head[v]=tot;
	}
	bool bfs()
	{
		memset(dis,-1,sizeof(dis));
		while(!q.empty()) q.pop(); q.push(S);dis[S]=0;
		while(!q.empty())
		{
			int x=q.front();q.pop();
			for(int i=head[x];i;i=e[i].nex)
			{
				int v=e[i].v;
				if(!e[i].w || ~dis[v]) continue;

				dis[v]=dis[x]+1;q.push(v);
			}
		}
		return ~dis[T];
	}
	int dfs(int x,int flow)
	{
		int used=0,u;
		if(x==T || !flow) return flow;
		for(int i=head[x];i;i=e[i].nex)
		{
			int v=e[i].v;
			if(dis[v]!=dis[x]+1 || !(u=dfs(v,min(flow-used,e[i].w)))) continue;
			used+=u;e[i].w-=u;e[i^1].w+=u;
			if(used==flow) break;
		}
		if(!used) dis[x]=-1;
		return used;
	}
	void dfsans(int x)
	{
		vis[x]=1;
		for(int i=head[x];i;i=e[i].nex)
			if(!vis[e[i].v] && e[i].w) dfsans(e[i].v);
	}
	void getans()
	{
		int res=0;while(bfs()) res+=dfs(S,INF);
		dfsans(S);
		for(int i=1;i<=m;++i) if(!vis[i]) ans1.pb(i);
		for(int i=2;i<=n;++i) if(vis[id[i][0]]) ans2.pb(id[i][0]-m);
		writeln(res);
		writesp(ans1.size());
		for(int i=0;i<(int)ans1.size();++i) writesp(ans1[i]); puts("");
		writesp(ans2.size());
		for(int i=0;i<(int)ans2.size();++i) writesp(ans2[i]); puts("");
	}
}

namespace Tree
{
	int tot,head[N],dep[N],fa[16][N];
	struct Tway{int v,nex;}e[N];
	void addedge(int u,int v)
	{
		e[++tot]=(Tway){v,head[u]};head[u]=tot;
		e[++tot]=(Tway){u,head[v]};head[v]=tot;
	}
	void dfs(int x)
	{
		for(int i=1;fc[i]<=dep[x];++i)
		{
			fa[i][x]=fa[i-1][fa[i-1][x]];id[x][i]=++cnt;
			Flow::add(id[x][i],id[x][i-1],INF);Flow::add(id[x][i],id[fa[i-1][x]][i-1],INF);
		}	
		for(int i=head[x];i;i=e[i].nex)
		{
			int v=e[i].v;
			if(v==fa[0][x]) continue;
			id[v][0]=m+(i+1)/2;Flow::add(id[v][0],Flow::T,1);
			dep[v]=dep[x]+1;fa[0][v]=x;dfs(v);
		}
	}
	int lca(int x,int y)
	{
		if(dep[x]<dep[y]) swap(x,y);
		for(int t=dep[x]-dep[y],i=0;i<16;++i) 
			if(fc[i]&t) x=fa[i][x];
		for(int i=15;~i;--i) if(fa[i][x]^fa[i][y]) 
			x=fa[i][x],y=fa[i][y];
		return x==y?x:fa[0][x];
	}
	void tagedge(int f,int x,int y)
	{
		int t=dep[x]-dep[y];
		for(int i=15;~i;--i) if(t&fc[i])
			Flow::add(f,id[x][i],INF),x=fa[i][x];
	}
}

namespace DreamLolita
{
	void init_tree()
	{
		fc[0]=1;for(int i=1;i<16;++i) fc[i]=fc[i-1]<<1;
		for(int i=1;i<n;++i) Tree::addedge(read(),read());
		Tree::dfs(1);
	}
	void solution()
	{
		n=read();m=read();cnt=m+n-1;Flow::S=0;Flow::T=N-5;Flow::tot=1;
		init_tree();
		for(int i=1;i<=m;++i)
		{
			Flow::add(Flow::S,i,1);
			int x=read(),y=read(),z=Tree::lca(x,y);
			Tree::tagedge(i,x,z);Tree::tagedge(i,y,z);
		}
		Flow::getans();
	}
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("CF786E.in","r",stdin);
	freopen("CF786E.out","w",stdout);
#endif
	DreamLolita::solution();
	return 0;
}

【总结】
不要越界！不要越界！不要越界！