HDU 6071 - 同余+最短路

 

Lazy Running

 

题意：给你一个由四个节点组成的环，求从节点2出发，回到节点2的不小于k的最短路。i只能跑向i+1或者i-1

思路：
根据限制条件，用邻接表建图，可以防止更新时有不合法的情况
因为要构成回路，考虑不绕圈，最小是选择与起点相邻的两条边构成回路。选择模数m，应该是min(a[1][0],a[1][2])*2  (下标从0开始）
用Dijkstra更新最短路，在 f[1][0...n]中进行求和。  （还可以参考一下这个思路 分析：ftae）

 

 

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <vector>
#define LL long long
#define P pair<LL,int>

using namespace std;

const int maxm=6e4+10,maxn=4;
const LL INF=0x3f3f3f3f3f3f3f3f;
struct Node
{
    int t;
    LL dis;
};
vector<Node> v[maxn];
LL f[maxn][maxm],K,m;

void dijkstra(int s)
{
    priority_queue<P,vector<P>,greater<P> > q;
    for(int i=0;i<maxn;++i)
        for(int j=0;j<=m;++j)
        f[i][j]=INF;
    q.push(P(0,s));
    LL x;int y;
    while(!q.empty())
    {
        x=q.top().first;
        y=q.top().second;
        q.pop();
        if(x>f[y][x%m]) continue;
        for(int i=0;i<v[y].size();++i)
        {
            int t=v[y][i].t;
            LL dis=x+v[y][i].dis;
            if(f[t][dis%m]>dis)
            {
                f[t][dis%m]=dis;
                q.push(P(dis,t));
            }
        }
    }
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int d1,d2,d3,d4;
        scanf("%lld%d%d%d%d",&K,&d1,&d2,&d3,&d4);
        memset(v,0,sizeof(v));
        v[0].push_back(Node{1,d1});
        v[1].push_back(Node{0,d1});
        v[1].push_back(Node{2,d2});
        v[2].push_back(Node{1,d2});
        v[2].push_back(Node{3,d3});
        v[3].push_back(Node{2,d3});
        v[3].push_back(Node{0,d4});
        v[0].push_back(Node{3,d4});
        m=min(d1,d2)*2;
        dijkstra(1);

        LL ans=INF,cnt;
        for(int i=0;i<m;++i)
        {
            cnt=K-f[1][i];
            if(cnt<=0) ans=min(ans,f[1][i]);
            else ans=min(ans,f[1][i]+cnt/m*m+(cnt%m>0?1:0)*m);
        }
        printf("%lld\n",ans);
    }
    return 0;
}