cf1163f-solution

CF1163F Solution

link

考虑求出从 \(1\) 和 \(n\) 开始的最短路树，如下图。

\(1\to a\to b\to\cdots\to x\to y\to n\) 是 \(1\) 到 \(n\) 的最短路。

分类讨论：

• 如果修改的边 \((u,v)\) 不在最短路上，

答案就是原来最短路长和过 \((u,v)\) 的最短路的最小值，这个容易预处理。从 \(1,n\) 分别跑一遍最短路即可。

• 如果修改的边 \((u,v)\) 在最短路上，

\(1)\) 如果边权变小，最短路径不变。长度修改一下就好。

\(2)\) 如果边权变大，

考虑过 \((u,v)\) 的最短路和不过 \((u,v)\) 的最短路。前者的路径就是原来最短路的路径，可以直接计算。

不过 \((u,v)\) 的最短路：考虑最终路径一定是先沿 \(1\to n\) 的最短路走一段，然后从某个点 \(b\) 走出这条主干，然后沿 \(1\) 的最短路树走一段，然后跳某条边 \((s,t)\) 跳到 \(n\) 的最短路树上，然后走回 \(1\to n\) 的最短路到达 \(n\)。

从图中看就是 \(1\to b\to s\to t\to x\to n\)，而且要满足 \(b\) 在 \(u\) 前面， \(x\) 在 \(v\) 后面。

于是对于每条不在最短路中的边，求出它的 \(u\) 在 \(1\) 的最短路树上往上跳到的主干对应位置（相当于 \(s\) 和 \(b\)），\(v\) 在 \(n\) 的最短路树上跳到位置。

塞进一个数据结构里，这样每次查询相当于查询所有 \(l\le x,r\ge x+1\) 的 \(dis\) 最小值。这就是一个二维数点。

当然也可以考虑每个 \([l,r]\) 对 \([l,r-1]\) 的 \(x\) 有 \(dis\) 的贡献，搞一个区间取 min，最后直接预处理每条边的答案。

复杂度 \(O(n\log n)\)，若 \(n,m\) 同阶。

Code

#include <bits/stdc++.h>
#define LL long long
#define sl(n) strlen(n)
#define endline puts("")
#define pii pair<int , int>
#define pr_q priority_queue
#define DEBUG puts("DEBUG.")
using namespace std;
const int N = 2e5 + 10;
const LL inf = ~0ull >> 2;
int n,m,q,cnt = 1,head[N];
struct edge
{
	int u,v,w;
	int nxt;
}edge[N << 1];
void add(int u , int v , int w = 0)
{
	++cnt,edge[cnt].u = u,edge[cnt].v = v,edge[cnt].w = w;
	edge[cnt].nxt = head[u],head[u] = cnt;
}
bool inp[N],ine[N << 1];
struct shortest_path
{
	LL dis[N];
	int pre[N],epre[N];
	bool vis[N];
	struct node
	{
		LL dis;
		int num;
		bool operator < (const node &x) const
			{return x.dis < dis;}
	};
	void dijk(int s)
	{
		memset( dis , 32 , sizeof(dis) );
		pr_q<node> q;
		dis[s] = 0,q.push( (node){0 , s} );
		while( !q.empty() )
		{
			int u = q.top().num;
			q.pop();
			if( vis[u] )
				continue;
			vis[u] = true;
			for(int i = head[u];i;i = edge[i].nxt)
			{
				int v = edge[i].v;
				if(dis[v] > dis[u] + edge[i].w)
				{
					dis[v] = dis[u] + edge[i].w,pre[v] = u,epre[v] = i;
					q.push( (node){dis[v] , v} );
				}
			}
		}
	}
}D[2];
vector<int> G[2][N];
int bel[2][N];
void dfs0(int u)
{
	if( inp[u] )
		++bel[0][u];
	for( auto v : G[0][u] )
	{
		bel[0][v] = bel[0][u];
		dfs0(v);
	}
}
void dfs1(int u)
{
	if( inp[u] )
		--bel[1][u];
	for( auto v : G[1][u] )
	{
		bel[1][v] = bel[1][u];
		dfs1(v);
	}
}
struct node
{
	LL mn,tag;
}t[N << 2];
LL ans[N];
void build(int o , int l , int r)
{
	t[o].mn = t[o].tag = inf;
	if(l == r)
		return ;
	int mid = l + r >> 1;
	build(o << 1 , l , mid);
	build(o << 1 | 1 , mid + 1 , r);
}
void push_down(int o)
{
	if(t[o].tag == inf)
		return ;
	LL &k = t[o].tag;
	o <<= 1;
	t[o].tag = min(t[o].tag , k),t[o].mn = min(t[o].mn , k);
	++o;
	t[o].tag = min(t[o].tag , k),t[o].mn = min(t[o].mn , k);
	k = inf;
}
void modify(int sl , int sr , int o , int l , int r , LL k)
{
	if(sl > sr)
		return ;
	if(sl <= l && r <= sr)
	{
		t[o].tag = min(t[o].tag , k),t[o].mn = min(t[o].mn , k);
		return ;
	}
	push_down(o);
	int mid = l + r >> 1;
	if(mid >= sl)
		modify(sl , sr , o << 1 , l , mid , k);
	if(mid + 1 <= sr)
		modify(sl , sr , o << 1 | 1 , mid + 1 , r , k);
	t[o].mn = min(t[o << 1].mn , t[o << 1 | 1].mn);
}
void dfs(int o , int l , int r)
{
	if(l == r)
	{
		ans[l] = t[o].mn;
		return ;
	}
	push_down(o);
	int mid = l + r >> 1;
	dfs(o << 1 , l , mid),dfs(o << 1 | 1 , mid + 1 , r);
}
signed main()
{
	cin >> n >> m >> q;
	for(int i = 1,u,v,w;i <= m;i++)
		scanf("%d%d%d" , &u , &v , &w),add(u , v , w),add(v , u , w);
	D[0].dijk(1),D[1].dijk(n);
	int u = n;
	while(u)
		ine[ D[0].epre[u] ] = ine[D[0].epre[u] ^ 1] = 1,inp[u] = 1,u = D[0].pre[u];
	for(int i = 1;i <= n;i++)
		for(int j = 0;j <= 1;j++)
			G[j][ D[j].pre[i] ].push_back(i);
	dfs0(1),bel[1][n] = bel[0][n] + 1,dfs1(n);
	int len = bel[0][n] - 1;
	build(1 , 1 , len);
	for(int i = 2;i <= cnt;i++)
	{
		if( ine[i] )
			continue;
		int l = bel[0][edge[i].u],r = bel[1][edge[i].v];
		LL k = D[0].dis[edge[i].u] + edge[i].w + D[1].dis[edge[i].v];
		modify(l , r - 1 , 1 , 1 , len , k);
	}
	dfs(1 , 1 , len);
	while(q--)
	{
		int x,y;
		scanf("%d%d" , &x , &y);
		int u = edge[x * 2].u,v = edge[x * 2].v,w = edge[x * 2].w;
		if( ine[x * 2] )
			if(y > w)
				printf( "%lld\n" , min( D[0].dis[n] - w + y , ans[ min( bel[0][u] , bel[0][v] ) ] ) );
			else
				printf("%lld\n" , D[0].dis[n] - w + y);
		else
			if(y > w)
				printf( "%lld\n" , D[0].dis[n] );
			else
				printf( "%lld\n" , min({D[0].dis[n] , D[0].dis[u] + y + D[1].dis[v] , D[0].dis[v] + y + D[1].dis[u]}) );
	}
	return 0;
}