第一周学习进度

1.1

P1586

题意：DAG，求从s到t所有不同的路径的长度和
SOL：考虑DP，$t[x]$表示点x会被经过多少次，对于边$(u,v,w)$，贡献为$w\ast t[x]$，$f[x]$表示到x的长度和，$f[v]+=f[u]+w\ast t[u]$，拓扑排序转移即可

P1983

题意：给定若干个1-n的子序列，每个子序列首尾之间未被选中的点的等级比被选中的点等级低，求整个序列最高等级的点的等级最小是多少
SOL：原题复杂度随便过，考虑更大的复杂度。
暴力做法：单独考虑每个子序列，未被选中的点向所有被选中的点连边表示一个小于关系，全连完边之后做拓扑排序。边数是$n^3$级别，n个序列，每个序列可以连$n^2$条边
优化1：设虚点，未被选中的点→虚点→被选中的点，每个序列优化到$O(n)$条边
优化2：线段树优化建图，考虑未被选中的点会被被选中的点分成一个一个区间，将未被选中的区间用线段树优化，进一步优化未选中的点→虚点这一层的边数至$O(logn)$

P4934

题意：给定若干个互不相同的数$a_i$，最小化分组数量，要求满足$a_i\&a_j\ge \min (a_i,a_j)$的不能分在一组，$n\le 10^6$
SOL：由于$a_i\&a_j\le \max (a_i,a_j)$，易得满足题意性质的只能是$a_i\&a_j=a_i,a_i<a_j$，考虑每个数向二进制1完全包含他的数连边，由于互不相同，则答案应该是图的最长路（不是互不相同要DP取max），边数是$n^2$级别的
优化一下边数，每个点可以只向和他有一位不同的点连边，这个不同是有传递性的，还是对的，就可以拓扑排序了

for (int i=0;i<(1<<k);i++)
{
	for (int now=1;now<=i;now<<=1)
		if (i&now) addedge(i,i-now);
}

1.8

P2597

题意：给定一个食物链，保证是个DAG，求对于每个生物，他如果灭绝了，会导致多少其他物种的灭绝。
SOL：支配树。
支配：对于一个有向图和起点s，称点k支配点x，当且仅当去掉点k后s无法到达x，即s到x的所有路径都经过k。
将一个点与他最近的支配点连边构成的树形结构就是支配树。
对于DAG求支配树，方法比较简单。
考虑一个点如果想要灭绝，那他的所有食物必须都灭绝，所以关系是“捕食者->被捕食者”，即捕食者的后继是被捕食者。对捕食关系构成的图做拓扑排序后，考虑在求解一个生物时，必须已经求解完所有的食物，所以要逆着拓扑序做。
那么一个点想要灭绝的条件是所有食物都灭绝，假设已经构建了所有食物的支配树，那么该点在支配树的父亲就应该是所有食物支配树的LCA。复杂度$O(m\log n)$，代码还闲的无事练习了一下继承

#include<bits/stdc++.h>
#define pa pair<int,int>
#define INF 0x3f3f3f3f
#define inf 0x3f
#define fi first
#define se second
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define pb push_back

using namespace std;

inline ll read()
{
	ll f=1,sum=0;char c=getchar();
	while (!isdigit(c)) {if (c=='-') f=-1;c=getchar();}
	while (isdigit(c)) {sum=sum*10+c-'0';c=getchar();}
	return sum*f;
}
const int MAXN=100010;
const int MAXM=1500010;
struct Tree{
	struct edge{
		int next,to;
	}e[MAXM];
	int head[MAXN],cnt;
	void addedge(int u,int v)
	{
		e[++cnt].next=head[u];
		e[cnt].to=v;
		head[u]=cnt;
	}
};
vector <int> tp_seq;
struct old_tree : Tree{
	int d[MAXN];
	void addedge(int u,int v)
	{
		Tree::addedge(u,v);
		d[v]++;
	}
	void tp_sort(int n)
	{
		queue <int> q;
		for (int i=1;i<=n;i++) if (!d[i]) q.push(i);
		while (!q.empty())
		{
			int x=q.front();
			q.pop();
			tp_seq.push_back(x);
			for (int i=head[x];i;i=e[i].next)
			{
				int v=e[i].to;
				d[v]--;
				if (!d[v]) q.push(v);
			}
		}
	}
}T;
const int LOG=18;
struct Dorm_Tree : Tree {
	int f[MAXN][LOG],sz[MAXN],deep[MAXN];
	int query(int x,int y)
	{
		if (deep[x]<deep[y]) swap(x,y);
		int d=deep[x]-deep[y];
		for (int i=0;i<LOG;i++) if (d&(1<<i)) x=f[x][i];
		if (x==y) return x;
		for (int i=LOG-1;i>=0;i--)
			if (f[x][i]!=f[y][i])
				x=f[x][i],y=f[y][i];
		return f[x][0];
	}
	void build(int n)
	{
		for (int i=1;i<n;i++) deep[i]=2,f[i][0]=n;
		deep[n]=1;
		for (int i=0;i<n;i++)
		{
			int x=tp_seq[i];
			int LCA=T.e[T.head[x]].to;
			//cout<<"!!"<<LCA<<endl;
			//for (int i=head[x];i;i=e[i].next)
			for (int i=T.e[T.head[x]].next;i;i=T.e[i].next)
			{
				int v=T.e[i].to;
				//cout<<v<<' '<<LCA<<endl;
				LCA=query(LCA,v);
			}
			//cout<<x<<"->"<<LCA<<endl;
			f[x][0]=LCA,addedge(LCA,x);
			deep[x]=deep[LCA]+1;
			for (int i=1;i<LOG;i++) f[x][i]=f[f[x][i-1]][i-1];
		}
	}
	void dfs(int x)
	{
		cout<<x<<endl;
		sz[x]=1;
		for (int i=head[x];i;i=e[i].next)
		{
			int v=e[i].to;
			dfs(v);
			sz[x]+=sz[v];
		}
	}
}D_T;
int main()
{
	int n=read();
	for (int i=1;i<=n;i++)
	{
		int fr=read();
		int num=0;
		while (fr)
		{
			T.addedge(fr,i);
			fr=read();
			num++;
		}
		if (!num) T.addedge(n+1,i);
	}
	n++;
	T.tp_sort(n);
	D_T.build(n);
	D_T.dfs(n);
	for (int i=1;i<n;i++) cout<<D_T.sz[i]-1<<'\n';
	return 0;
}

1.10

欧拉回路：无向图所有点都是偶度，随便定起点终点，有向图所有点入度=出度，随便定起点终点。
欧拉路：无向图有两个奇度点，一个起点一个终点，有向图有恰好一个度为1和恰好一个度为-1，一个起点一个终点
大部分时候不需要写出来路径是什么，只需要用到思想。
P6628
题意：给定一个n个点的完全图，每条边的长度为两点编号之差的绝对值，给定m条边为必须经过，给定起点s，求从起点s经过必经边到达每个点的最短距离。
SOL：如果只考虑必经边，本题转化为添加一些边，使得原图是s到i的欧拉路。先对给定的边求出每个点的度数并算出必须走的长度和，给s和i连一条边（不算长度，后续处理方便），然后把所有奇度点拿出来，相邻的奇度点连边肯定代价最小。然后整个图变成了若干个“欧拉联通块”，再在所有的联通块之间加两条边即可，本质是把所有相邻的点拿出来做最小生成树，注意要把零度点踢掉，没有必要访问到。
还有个小坑，在连接相邻奇度点的时候，虽然本质是连了一条长为u-v的边，但是可以看做是连接了u-v条长度为1的边，这样可以把两个奇度点之间夹着的偶度联通块合并起来，为第二步合并欧拉联通块节省距离。

#include<bits/stdc++.h>
#define pa pair<int,int>
#define INF 0x3f3f3f3f
#define inf 0x3f
#define fi first
#define se second
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define pb push_back

using namespace std;

inline ll read()
{
	ll f=1,sum=0;char c=getchar();
	while (!isdigit(c)) {if (c=='-') f=-1;c=getchar();}
	while (isdigit(c)) {sum=sum*10+c-'0';c=getchar();}
	return sum*f;
}
const int MAXN=2510;
int d[MAXN],fa[MAXN];
int find(int x)
{
	if (fa[x]!=x) fa[x]=find(fa[x]);
	return fa[x];
}
int prefa[MAXN];
int findpre(int x)
{
	if (prefa[x]!=x) prefa[x]=findpre(prefa[x]);
	return prefa[x];
}

int main()
{
	int n=read(),m=read(),st=read();
	int presum=0;
	for (int i=1;i<=n;i++) prefa[i]=i;
	for (int i=1;i<=m;i++)
	{
		int u=read(),v=read();
		d[u]++,d[v]++;
		int f1=findpre(u),f2=findpre(v);
		if (f1!=f2) prefa[f1]=f2;
		presum+=abs(u-v);
	}
	for (int ed=1;ed<=n;ed++)
	{
		//cout<<ed<<"----\n";
		int ans=presum;
		for (int i=1;i<=n;i++) fa[i]=findpre(prefa[i]);
		d[ed]++,d[st]++;
		if (find(ed)!=find(st)) fa[find(ed)]=find(st);
		vector <int> vec;
		for (int i=1;i<=n;i++) if (d[i]&1) vec.push_back(i);
		//cout<<vec.size()<<endl;
		for (int i=1;i<vec.size();i+=2)
		{
			ans+=vec[i]-vec[i-1];
			for (int j=vec[i-1];j<vec[i];j++)
			{
				int f1=find(j),f2=find(j+1);
				if (f1!=f2) fa[f1]=f2;			
			}
		}
		//cout<<ans<<endl;
		vec.clear();
		for (int i=1;i<=n;i++) if (d[i]) vec.push_back(i);
		//cout<<vec.size()<<endl;
		vector <pair<int,pa>> e;
		for (int i=1;i<vec.size();i++)
		{
			int u=find(vec[i-1]),v=find(vec[i]);
			if (u==v) continue;
			//cout<<vec[i-1]<<" "<<vec[i]<<endl;
			e.push_back(mp(abs(vec[i]-vec[i-1]),mp(u,v)));
		}
		sort(e.begin(),e.end());
		for (int i=0;i<e.size();i++)
		{
			int f1=find(e[i].se.fi),f2=find(e[i].se.se);
			if (f1==f2) continue;
			fa[f1]=f2;
			ans+=2*e[i].fi;
		}
		d[ed]--,d[st]--;
		cout<<ans<<' ';
	}
	return 0;
}

1.12

tarjan算法，注意low数组的含义是只走小于等于一条返祖边能够到达的最小dfn

1.15

强连通分量对应有向图
双连通分量对应无向图