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 thanK

meters.
There are 4 checkpoints in the campus, indexed as p1,p2,p3 and p4. Every time you pass a checkpoint, you should swipe your card, then the distance between this checkpoint and the last checkpoint you passed will be added to your total distance.
The system regards these 4 checkpoints as a circle. When you are at checkpoint pi, you can just run to pi−1 or pi+1(p1 is also next to p4). You can run more distance between two adjacent checkpoints, but only the distance saved at the system will be counted.
 

Checkpoint p2 is the nearest to the dormitory, Little Q always starts and ends running at this checkpoint. Please write a program to help Little Q find the shortest path whose total distance is not less thanK

.

Input

The first line of the input contains an integer T(1≤T≤15), denoting the number of test cases.
In each test case, there are 5 integers K,d1,2,d2,3,d3,4,d4,1(1≤K≤1018,1≤d≤30000), denoting the required distance and the distance between every two adjacent checkpoints.

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

        比賽的時候就是蠢……

        當時只剩下十幾分鐘的時候看到這題的……其實很簡單的一道最短路，前提是想到了……

        題目要求是隻有四個點，然後連邊成正方形，問從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的所有剩餘系都被包括了，所以可以保證正確性。具體程式碼如下：

#include<bits/stdc++.h>
#define LL long long
using namespace std;

struct Edge{int y;LL w;};
typedef pair<LL,int> P;
vector<Edge> g[4];
LL d[4][100000],K,m;
int n,s;

inline void dijkstra(int s)
{
    priority_queue<P,vector<P>,greater<P> > q;
    for(int i=0;i<n;i++)
        for(int j=0;j<=m;j++)
            d[i][j]=2000000000000000000;
    q.push(P(0LL,s));							//d[s][0]不能賦值為0
    while (!q.empty())
    {
        LL w=q.top().first;
        int j=q.top().second;
        q.pop();
        if (w>d[j][w%m]) continue;
        for(int k=0;k<g[j].size();k++)
        {
            int y=g[j][k].y;
            LL dist=w+g[j][k].w;
            if (d[y][dist%m]>dist)					//更新的時候更新取模後對應的點
            {
                d[y][dist%m]=dist;
                q.push(P(dist,y));
            }
        }
    }
}

int main()
{
    n=4;
    s=1;
    int T_T;
    cin>>T_T;
    while(T_T--)
    {
        int d1,d2,d3,d4;
        memset(g,0,sizeof(g));
        scanf("%I64d%d%d%d%d",&K,&d1,&d2,&d3,&d4);
        g[0].push_back(Edge{1,d1});
        g[1].push_back(Edge{0,d1});
        g[1].push_back(Edge{2,d2});
        g[2].push_back(Edge{1,d2});
        g[2].push_back(Edge{3,d3});
        g[3].push_back(Edge{2,d3});
        g[3].push_back(Edge{0,d4});
        g[0].push_back(Edge{3,d4});
        m=2*min(d1,d2);							//為了使效率更高，w取兩條與2相連的邊中小的那個
        dijkstra(s);
        LL ans=2000000000000000000;
        int p;
        for(int i=0;i<m;i++)						//列舉剩餘系下所有的可能的最小花費
        {
            LL delta=K-d[1][i];
            if (delta<=0) ans=min(ans,d[1][i]);
            else ans=min(ans,d[1][i]+delta/m*m+(delta%m>0)*m);
        }
        printf("%I64d\n",ans);
    }
    return 0;
}