這道題題意也是很簡單，給出一個4個點的無向圖，組成了一個環路

從2點出發，隨便跑，然後再從2點結束，問怎麼個跑法讓距離總和在超過k的前提下最短。
一步一步來想這道題，瞎幾把暴力深搜可以出答案啊。
當然複雜度很高，那加個記憶化搜尋，dp[4][k+30000]，dp[i][j]表示的是從2開始出發來到i那個點，距離有沒有距離為j的走法，有就true，沒有就false，當深搜的時候遇到已經true了，那可以不用進行下去，優秀了很多。但是dp根本開不來那麼大的，k去到1e18了。空間爆炸，並且也沒有利用到題目中一個很重要的特點，這個圖其實可以看成每個點自己本身帶了一個自環，比如2點可以去到1點，然後1點回來2點，也就是2點本身有一個長度為2*d12的自環，同理有還有一個2*d23的自環，這個怎麼用呢？

先在記憶化搜尋的基礎上考慮這麼一個問題，如果d12長度是5，然後記憶化深搜的過程中，找到dp[i][4]=true,dp[i][14]=true,就是說到達從2到達i點可以走4長度或者14長度，其實我們可以只保留那個小的值就足夠了，為什麼，因為14長度的其實可以由4長度的，加上2-1-2這樣往返跑一輪得到14，同理24，34，44……這些也都沒必要去記錄了。所以dp可以縮減為dp[4][d12的長度*2]，把深搜走的距離長度dis%(d12的長度*2),對應到dp中，dp存dis的最小值，只要有了這個最小值，就能加上往返跑的方法跑出其他值來，這樣就達到了節約空間時間的複雜度，因為那些很多狀態其實都是一樣的。往返跑的邊可以選d12或者d23，都可以，區別是dp陣列的大小不同

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3e4+10;
const long long INF = 1e19;
int d[5][5];
long long dp[5][MAXN*2];
struct Dis
{
    int u,d;
    friend bool operator < (const Dis &a,const Dis &b)
    {
        return a.d>b.d;
    }
};
long long dfs(long long k)
{
    for
 
(int i=1;i<=4;i++)
        fill(dp[i],dp[i]+MAXN*2,INF);
    dp[2][0]=0;
    int m=min(d[1][2],d[2][3])*2;
    priority_queue<Dis> que;
    que.push({2,0});
    while(que.size())
    {
        Dis top=que.top();que.pop();
        int u=top.u;
        for(int v=1;v<=4;v++)
        {
            if(d[u][v])
            {
                long long dis=top.d+d[u][v];
                if(dp[v][dis%m]>dis)
                {
                    dp[v][dis%m]=dis;
                    que.push({v,dis});
                }
            }
        }
    }
    long long ans=INF;
    for(int i=0;i<m;i++)
    {
        if(dp[2][i]==INF) continue;
        long long dis;
        if(dp[2][i]>k)
            dis=dp[2][i];
        else
            dis=(k-dp[2][i])/m*m+dp[2][i];
        while(dis<k) dis+=m;
        ans=min(dis,ans);
    }
    return ans;
}
int main()
{
    if (fopen("in.txt", "r") != NULL)
    {
        freopen("in.txt", "r", stdin);
        // freopen("out.txt", "w", stdout);
    }
    int t;
    cin>>t;
    while(t--)
    {
        long long int k;
        cin>>k>>d[1][2]>>d[2][3]>>d[3][4]>>d[4][1];
        d[2][1]=d[1][2];
        d[3][2]=d[2][3];
        d[4][3]=d[3][4];
        d[1][4]=d[4][1];
        cout<<dfs(k)<<'\n';
    }
    return 0;
}