图论学习：分层图

分层图的应用范围：

比如最短路、网络流等，题目对边的权值提供可选的操作，比如可以将一定数量的边权减半，在此基础上求解最优解。

分层图的构建步骤可以描述为：
1、先将图复制成 k+1 份 （0 ~ k）
2、对于图中的每一条边 <u,v> 从 ui 到 vi+1 建立与题目所给操作相对应的边（i=0,1,…,k）

k代表了进行操作的次数，而每层之间点的关系代表了何时进行操作。

例题1：
洛谷P4822 [BJWC2012]冻结
题意：给你一个n个点m条边的无向带权图，每条边有一个通过时间w，现在你最多有k次操作可以在通过某条路径的时候将时间变为原来的一半，问你从1到n需要的最短时间是多少？

题解：建立分层图，层与层之间点的边权为原来的1/2，同层之间边的权值不变

点击查看折叠代码块

#include <bits/stdc++.h>
using namespace std;
const int maxm = 1e4+10;
const int maxk = 55;
const int maxn = 55;
const int inf=0x3f3f3f3f;
typedef long long ll;
typedef pair<int,int> pii;

int head[maxn*maxk],cnt=0;
struct edge{
    int v,next;
    int w;
}e[maxm*maxk*2];

void add(int u,int v,int w){
    e[cnt].v=v;
    e[cnt].w=w;
    e[cnt].next=head[u];
    head[u]=cnt++;
}

int n,m,k;
int dis[maxn*maxk];
bool vis[maxn*maxk];

void dijkstra(int s){
    memset(vis,0,sizeof(vis));
    memset(dis,inf,sizeof(dis));
    dis[s] = 0;
    priority_queue<pii,vector<pii>,greater<pii> > q;
    q.push(make_pair(0,s));

    while(!q.empty()){
        int u = q.top().second;
        q.pop();
        // cout<<" u = "<<u<<endl;
        if(vis[u]) continue;
        vis[u] = 1;
        for (int i=head[u];~i;i=e[i].next){
            int v=e[i].v;
            if(dis[v]>dis[u]+e[i].w){
                dis[v]=dis[u]+e[i].w;
                q.push(make_pair(dis[v],v));
            }
        }
    }
}

int main(){
    memset(head,-1,sizeof(head));
    cin>>n>>m>>k;
    for (int i=1;i<=m;i++){
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);add(v,u,w);//第0层
        for (int j=1;j<=k;j++){//建立k层
            add(u+j*n-n,v+j*n,w/2);
            add(v+j*n-n,u+j*n,w/2);
            add(u+j*n,v+j*n,w);
            add(v+j*n,u+j*n,w);
        }
    }
    dijkstra(1);
    int ans = inf;
    for (int i=0;i<=k;i++){
        ans=min(ans,dis[n+i*n]);
    }
    cout<<ans<<endl;
    return 0;
}

例题2：
洛谷P2939 [USACO09FEB]Revamping Trails G
题意：同上，只是把边权从w/2变为了0

点击查看折叠代码块

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,int> pii;

const int maxn=1e4+10;
const int maxk=21;
const int maxm=5e5+10;
const ll inf=0x3f3f3f3f3f3f;

struct edge{
    int v,next;
    int w;
}e[maxm*maxk*2];
int head[maxn*maxk],cnt = 0;
bool vis[maxn*maxk];
ll dis[maxn*maxk];

void add(int u,int v,int w){
    e[cnt].v=v;
    e[cnt].w=w;
    e[cnt].next=head[u];
    head[u]=cnt++;
}
int n,m,k;

void bfs(int s){
    for (int i=0;i<maxn*maxk;i++){
        dis[i] = inf;
        // cout<<dis[i]<<endl;
    } 
    memset(vis,0,sizeof(vis));
    dis[s] = 0;
    priority_queue<pii,vector<pii>,greater<pii> > q;
    q.push(make_pair(dis[s],s));
    while(!q.empty()){
        int u=q.top().second;
        q.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for (int i=head[u];~i;i=e[i].next){
            int v=e[i].v;
            if(dis[v]>dis[u]+e[i].w){
                dis[v]=dis[u]+e[i].w;
                q.push(make_pair(dis[v],v));
            }
        }
    }
}
int main(){
    memset(head,-1,sizeof(head));

    cin>>n>>m>>k;
    for (int i=1;i<=m;i++){
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);
        add(v,u,w);
        for (int j=1;j<=k;j++){
            add(u+j*n-n,v+j*n,0);
            add(v+j*n-n,u+j*n,0);
            add(u+j*n,v+j*n,w);
            add(v+j*n,u+j*n,w);
        }
    }
    bfs(1);
    ll ans = inf;
    for (int i=0;i<=k;i++){
        ans=min(ans,dis[n+i*n]);
    }
    cout<<ans<<endl;
    return 0;
}

例题3：
牛客Rinne Loves Dynamic Graph

题解：
经过几次推导，可以容易发现f函数是一个迭代函数，迭代3次之后会回到F(x)=x，因此我们建立分层图，分为三层，第0层到第1层的边权值是x，第1层到第2层的权值是fabs(1/(1-x))...，最后从第二层连回第一层
然后跑最短路取个最小值就可以了

点击查看折叠代码块

#include <bits/stdc++.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=3e5+10;
typedef long long ll;
const int inf=0x3f3f3f3f;
int n,m;
int q;
struct edge{
	int v,next;
	double w;
}e[maxm<<4];
int head[maxn<<3],cnt=0;
void add(int u,int v,double w){
	e[++cnt].v=v;
	e[cnt].w=w;
	e[cnt].next=head[u];
	head[u]=cnt;
}
bool vis[maxn<<4];
double dis[maxn<<4];

struct node{
	int u;
	double w;
	bool operator < (const node&rhs) const{
		return w>rhs.w;
	}
	node (int id = 0,double ww = 0.):u(id),w(ww){}
};

void bfs(){
	memset(vis,0,sizeof(vis));
	for (int i=1;i<=3*n;i++){
		dis[i] = 1.0*inf;
	}
	dis[1]=0;
	priority_queue<node> q;
	q.push(node(1,0));
	while(!q.empty()){
		int u=q.top().u;
		q.pop();
		if(vis[u]) continue;
		vis[u] = 1;
		for (int i=head[u];i;i=e[i].next){
			int v=e[i].v;
			double w=e[i].w;
			if(dis[v]>dis[u]+w){
				dis[v]=dis[u]+w;
				q.push(node(v,dis[v]));
			}
		}
	} 
}
int main(){
	cin>>n>>m;
	for (int i=1;i<=m;i++){
		int u,v;
		double w;
		scanf("%d%d%lf",&u,&v,&w);
		//第一层 
		add(u,v+n,fabs(w));
		add(v,u+n,fabs(w));
		//第二层
		w=1.0/(1-w);
		add(u+n,v+2*n,fabs(w));
		add(v+n,u+2*n,fabs(w));
		//第三层
		w=1.0/(1-w);
		add(u+2*n,v,fabs(w));
		add(v+2*n,u,fabs(w));
	}
	bfs();
	double ans = 1.0*inf;
	for (int i=1;i<=3;i++){
		ans=min(ans,dis[i*n]);
	}
	if(ans > (inf-1)) puts("-1
");
	else printf("%.3f
",ans);
	return 0;
}

例题4：
P3119 [USACO15JAN]Grass Cownoisseur G
题意：有一个n个点m条边的有向图，现在你要从1点出发，问你在最多可以逆行一次的情况下，最多能遍历图中的多少个点后回到1点，重复遍历的点只算一次
例如：1-2-4-7-2-5-3-1,答案为6

做法：
先将图中存在的环进行缩点，缩点之后图就变成了DAG，然后再在新图上建立分层图，
假设有一条边为u-v
共分为两层：
第0层：u-v
第1层：u+n-v+n （n为缩点之后新图点的个数）
第1层到第0层：v-u+n (表示一条可逆行的边)

注：第1层的每个点的权值应该和第0层相同

之后在分层图上跑spfa求最长路，然后我们每次求dis[v] = dis[u] + w时，w等于点u的权值，这样就可以保证点book[1] (新图点1的编号) 的权值只计算了一遍，同时，层与层之间只有一条单向边，且每层都是一个无环图，这样也可以保证其他点的权值也只算了一遍，最后答案就是dis[book[1]+n]

点击查看折叠代码块

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int ,int> pii;

const int inf=0x3f3f3f3f;
const int maxn=1e6+10;
const int maxm=1e6+10;
struct edge{
    int u,v,next;
}e[maxm<<2];
int head[maxn],cnt=0;

void add(int u,int v){
    e[cnt].u=u;
    e[cnt].v=v;
    e[cnt].next=head[u];
    head[u]=cnt++;
}

int dfn[maxn],low[maxn],tot=0;
int book[maxn],num[maxn],ct=0;
bool instack[maxn];
stack<int> st;

int n,m;
void tarjan(int u){
    dfn[u]=low[u]=++tot;
    st.push(u);
    instack[u]=1;
    for (int i=head[u];~i;i=e[i].next){
        int v=e[i].v;
        if(!dfn[v]){
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v]){
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(dfn[u] == low[u]){
        ct++;
        while(1){
            int x=st.top();
            st.pop();
            instack[x]=0;
            book[x]=ct;
            num[ct]++;
            if(x == u) break;
        }
    }
}

int dis[maxn];
bool vis[maxn];

void spfa(int s){//缩点之后变为DAG
    for (int i=1;i<maxn;i++) dis[i] = -inf;
    memset(vis,0,sizeof(vis));
    dis[s] = 0;
    vis[s] = 1;

    queue<int> q;
    q.push(s);
    while(!q.empty()){
        int u = q.front();
        q.pop();
        vis[u] = 0;
        for (int i=head[u];i!=-1;i=e[i].next){
            int v=e[i].v;
            int w=num[u];
            if(dis[v] < dis[u] + w){
                dis[v] = dis[u] + w;
                if(!vis[v]){
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
}

void Clear(){//清空图
    memset(e,0,sizeof(e));
    memset(head,-1,sizeof(head));
    cnt=0;
}

int x[maxn],y[maxn];

int main(){
    memset(head,-1,sizeof(head));
    cnt=0;
    cin>>n>>m;
    for (int i=1;i<=m;i++){
        scanf("%d%d",&x[i],&y[i]);//建分层图先存图,不然导致内存出问题,卡死我了qwq
        add(x[i],y[i]);
    }
    for (int i=1;i<=n;i++){
        if(!dfn[i]){
            tarjan(i);
        }
    }
    Clear();
    for (int i=1;i<=m;i++){//缩点后建分层图
        int u=book[x[i]],v=book[y[i]];
        if(u!=v){
            add(u,v);//第0层
            add(u+ct,v+ct);//第1层
            add(v,u+ct);//第0层到第1层建一条逆向边
        }
    }
    for (int i=1;i<=ct;i++){//第二层复制一遍第一层的点权
        num[i+ct] = num[i];
    }
    //跑最长路
    spfa(book[1]);
    int ans = dis[book[1]+ct];
    cout<<ans<<endl;
    return 0;
}