HDU 6071 Lazy Running 同余 + 最短路

传送门：HDU6071

题意：给你一个由四个节点组成的环，相邻两点间可达，求从节点2出发，回到节点2的不小于k的最短路径的长度。

思路：

先摆上官方题解：

​​

取w=\min(d_{1,2},d_{2,3})w=min(d​1,2​​,d​2,3​​)，那么对于每一种方案，均可以通过往返跑$w$这条边使得距离增加$2w$。也就是说，如果存在距离为$k$的方案，那么必然存在距离为$k+2w$的方案。

设dis_{i,j}dis​i,j​​表示从起点出发到达$i$，距离模$2w$为$j$时的最短路，那么根据dis_{2,j}dis​2,j​​解不等式即可得到最优路线。

时间复杂度$O(w\log w)$。

也就是说，假设我们将任意一条长度大于k的回路（从2出发回到2）成为可行路径，那么任意一条可行路径加上2w一定还是一条可行路径，所有可行路径中，最短的是k，最长的为 k + 2 * n * w,(n趋近正无穷),显然我们不可能求出所有的可行路径来，由于所有可行路径长度中都含有2w（有可能含0个），我们可以考虑按对2w的余数分块，这样我们只要求出%2w == 0的最短可行路径，%2w == 1的最短可行路径。。。一直到%2w == 2w - 1的最短可行路径，然后在这2w条可行路径中找一条最短的就是答案了（因为这条一定是所有可行路径中最短的那条）

然后问题就是如何求出%2w同余的所有可行路径中最短的那条了，用dis[i][j]表示从2号点出发到达i，长度%2w为j的最短路径的长度（注意这里不一定是可行路径，长度可以小于K，因为我们可以最后再添几个2w使其刚好大于K，并且添加2w以后并不会改变其长度%2w == j的性质），这个数组可以用dijkstra的思想求出来，注意要加堆优化。

代码：

#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define fi first
#define se second
#define pi acos(-1)
#define inf 0x3f3f3f3f3f3f3f3f
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define rep(i,x,n) for(int i=x;i<n;i++)
#define per(i,n,x) for(int i=n;i>=x;i--)
using namespace std;
typedef pair<ll,int>P;
const int MAXN=100010;
int gcd(int a,int b){return b?gcd(b,a%b):a;}
priority_queue<P, vector<P>, greater<P> > q;
struct node{
	int v, w;
	node(){}
	node(int _v, int _w) : v(_v), w(_w){}
}g[5][2];
ll dis[5][60060];
void dijkstra(int k)
{
	memset(dis, inf, sizeof(dis));
	dis[2][0] = 0;
	q.push(P(0, 2));
	while(!q.empty())
	{
		P u = q.top(); q.pop();
		if(u.fi > dis[u.se][u.fi % k]) continue;
		for(int i = 0; i < 2; i++)
		{
			ll w = u.fi + g[u.se][i].w;
			int v = g[u.se][i].v;
			if(dis[v][w % k] > w)
			{
				dis[v][w % k] = w;
				q.push(P(w, v));
			}
		}
	}
}
int main()
{
	int T;
	cin >> T;
	while(T--)
	{
		ll k;
		scanf("%lld %d %d %d %d", &k, &g[1][0].w, &g[2][0].w, &g[3][0].w, &g[4][0].w);
		g[1][0].v = 2;
		g[2][0].v = 3;
		g[3][0].v = 4;
		g[4][0].v = 1;
		g[1][1] = node(4, g[4][0].w);
		g[2][1] = node(1, g[1][0].w);
		g[3][1] = node(2, g[2][0].w);
		g[4][1] = node(3, g[3][0].w);
		int w = min(g[1][0].w, g[2][0].w) * 2;
		dijkstra(w);
		ll ans = inf, tmp;
		for(int i = 0; i <= w; i++)
		{
			if(dis[2][i] > k)
			ans = min(ans, dis[2][i]);
			else
			{
				tmp = (k - dis[2][i]) / w * w + dis[2][i];
				if((k - dis[2][i]) % w)
				tmp += w;
				ans = min(ans, tmp);
			}
		}
		cout << ans << endl;
	}
 	return 0;
}