HDU6071-最短路

http://acm.hdu.edu.cn/showproblem.php?pid=6071

  四个点围成一个环，相邻两点之间存在路径，问从2号点出发最后再次回到二号点，在路程大于等于K的情况下的最小路程量。

我们令m=min(d1,d2)*2,可以想做是回到2号点之后再重复的走若干个m后的路程。（当然m也可以是max(d1,d2)*2,因为只要和2相邻即可)。

f[i][j]表示从2出发达到i之后，走过路程f[i][j]%m=j的最小路程，跑一遍dij，最后统计结果如果不足k就加上m补足。

  这样之所以是正确的在于考虑了所有的情况，对于同一个模m剩余系里面的路程他们之间的差值一定是m的倍数，所以选出一个最小的如果不足k用m补足

相当于还原到另一个路程上了，也能找到最优解。

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<cmath>
#include<cstring>
#include<bits/stdc++.h>
#define LL long long
using namespace std;
#define LL long long
struct Edge
{
    LL u,w;
};
struct node
{
    LL u,w;
    bool operator<(const node&chs)const{
        return w>chs.w;
    }
};
LL f[4][60010];
vector<Edge> g[4];
void dij(LL m)
{
    memset(f,-1,sizeof(f));
    f[1][0]=0;
    priority_queue<node>q;
    q.push(node{1,0});
    while(!q.empty()){
        int u=q.top().u,
            w=q.top().w;
        q.pop();
        for(int i=0;i<g[u].size();++i){
            if(w+g[u][i].w<f[g[u][i].u][(w+g[u][i].w)%m]||f[g[u][i].u][(w+g[u][i].w)%m]==-1){
                f[g[u][i].u][(w+g[u][i].w)%m]=w+g[u][i].w;
                q.push(node{g[u][i].u,f[g[u][i].u][(w+g[u][i].w)%m]});
            }
        }
    }
}
int main()
{
    LL n,m,i,j,k,d[4],t;
    cin>>t;
    while(t--){
        cin>>k;
        for(i=0;i<4;++i)cin>>d[i],g[i].clear();
        g[0].push_back(Edge{1,d[0]});
        g[0].push_back(Edge{3,d[3]});

        g[1].push_back(Edge{0,d[0]});
        g[1].push_back(Edge{2,d[1]});

        g[2].push_back(Edge{1,d[1]});
        g[2].push_back(Edge{3,d[2]});

        g[3].push_back(Edge{0,d[3]});
        g[3].push_back(Edge{2,d[2]});

        m=min(d[0],d[1])*2;
        dij(m);
        LL ans=1e18;
        for(i=0;i<m;++i){
            if(f[1][i]==-1) continue;
            if(f[1][i]>=k) ans=min(ans,f[1][i]);
            else{

                ans=min(ans,f[1][i]+
                        (k-f[1][i])/m*m+((k-f[1][i])%m>0)*m);
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}