HDU 6071 Lazy Running （同余最短路）

Lazy Running

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 524288/524288 K (Java/Others)
Total Submission(s): 101 Accepted Submission(s): 40

Problem Description

In HDU, you have to run along the campus for 24 times, or you will fail in PE. According to the rule, you must keep your speed, and your running distance should not be less than

Checkpoint

Input

The first line of the input contains an integer

Output

For each test case, print a single line containing an integer, denoting the minimum distance.

Sample Input

1 2000 600 650 535 380

Sample Output

2165

Hint

The best path is 2-1-4-3-2.

Source

2017 Multi-University Training Contest - Team 4

比赛的时候就是蠢……

当时只剩下十几分钟的时候看到这题的……其实很简单的一道最短路，前提是想到了……

题目要求是只有四个点，然后连边成正方形，问从2号点出发，再回到2号点且走过的总距离大于K的最短的路径是多少。对于这个，我们考虑如果存在一条合法路径，那么我再走2*w也一定是合法路径，其中w表示与2相连的某条边的长度。即回到2之后再出去再回来，这样的路径一定合法。那么，如果走了某条路径回到了2，然后总距离不够的话，我们只需要加上几个2*w使得最后结果大于等于K即可。

那么如何使这个结果最小呢？我们考虑设置一个数组d[x][p]表示从2出发最后到达x点且费用对2*w取模结果为p时的最小花费。这样子原本的一个点就可以拆成2*w个点，这样跑一遍dijkstra即可求出d数组。之后，对于每一个对2*w取模后的数值，我们都可以计算把它补到大于K且距离K最近的花费，再在这些花费中取一个最小的即可。那么，这样子考虑为什么可以包含全部的而且最优的解呢？因为我们最后补的是2*w或者它的倍数，然后我把对2*w取模后的所有取值的最小花费都计算了一次，这样子得出来的最小花费一定包含所有的情况，即2*w的所有剩余系都被包括了，所以可以保证正确性。具体代码如下：

转载于http://blog.csdn.net/yasola/article/details/76684704；

#include <iostream>    
#include <algorithm>    
#include <cstdio>    
#include <cstring>    
#include <cstdlib>    
#include <cmath>    
#include <ctime>    
#include <vector>    
#include <queue>    
#include <stack>    
#include <deque>    
#include <string>    
#include <map>    
#include <set>    
#include <list>    
using namespace std;    
#define INF 0x3f3f3f3f3f3f3f3f  
#define LL long long    
#define fi first    
#define se second    
#define mem(a,b) memset((a),(b),sizeof(a))    
  
const int MAXN=4+3;  
const int MAXM=60000+3;  
  
struct Node  
{  
    int p;  
    LL dis;  
    Node(int p, LL d):p(p), dis(d){}  
};  
  
LL K, G[MAXN][MAXN], m, ans;  
bool vis[MAXN][MAXM];  
LL dist[MAXN][MAXM];//从1开始到达i，模m等于j的最短路  
  
void spfa(int s)  
{  
    queue<Node> que;  
    mem(vis, 0);  
    mem(dist, 0x3f);  
    que.push(Node(1, 0));  
    dist[1][0]=0;  
    vis[1][0]=true;  
    while(!que.empty())  
    {  
        int u=que.front().p;  
        LL now_dis=que.front().dis;  
        vis[u][now_dis%m]=false;  
        que.pop();  
        for(int i=-1;i<2;i+=2)  
        {  
            int v=(u+i+4)%4;  
            LL next_dis=now_dis+G[u][v], next_m=next_dis%m;  
            if(v==s)//形成环，更行答案  
            {  
                if(next_dis<K)  
                    ans=min(ans, next_dis+((K-next_dis-1)/m+1)*m);  
                else ans=min(ans, next_dis);  
            }  
            if(dist[v][next_m]>next_dis)  
            {  
                dist[v][next_m]=next_dis;  
                if(!vis[v][next_m])  
                {  
                    que.push(Node(v, next_dis));  
                    vis[v][next_m]=true;  
                }  
            }  
        }  
    }  
}  
  
int main()  
{  
    int T_T;  
    scanf("%d", &T_T);  
    while(T_T--)  
    {  
        scanf("%lld", &K);  
        for(int i=0;i<4;++i)  
        {  
            scanf("%lld", &G[i][(i+1)%4]);  
            G[(i+1)%4][i]=G[i][(i+1)%4];  
        }  
        m=2*min(G[1][0], G[1][2]);//最小环  
        ans=((K-1)/m+1)*m;//只使用最短的回路  
        spfa(1);  
        printf("%lld\n", ans);  
    }  
      
    return 0;  
}

posted @ 2017-08-23 19:53 贱人方阅读(196) 评论(0) 编辑收藏举报

刷新页面返回顶部

贱人方

HDU 6071 Lazy Running （同余最短路）

Lazy Running

公告