今天写这道题的过程就一直在摆，主要是写不太出来，之前想到动态规划去了，然后又开始深搜，在出口那块放动态规划
题：
D. Ela and the Wiring Wizard
点我
但是cf让我明白了一个道理，任何一道我写不出来的题代码不会超过50行，嘤（的确，太长的也不太好调试，这样的题显然不是模拟，要推出一些结论，然后往上整
这个题的大意是$u_i,v_i,t_i$通过$v_i$相连，那么可以花费$u_i,v_i$之间的权重把这两条边断开，然后把$u_i,t_i$连在一起，这样的话走$u_i,t_i$就可以使用$u_i,v_i$之间的权重了。这样的操作可以进行任意多次，求最后从$1\to n$的最小花费是多少，把消边的时间也要算上。
现在看来，我的做法的确很沙雕。我的错误在于，我是深搜出一条从$1$到$n$的路径，然后把这条路径动规，但是这里面有一个问题就是，如果一开始的一条路径不能从$1$走到$n$，这条路径也有可能通过操作最短。
你看这个图，他的答案是$154$，为啥，我当时还在想是$43，54$怎么组合，因为我算的一直都是$162$，后来我才明白，他一直在用$22$那条边来回倒。
你可以

比如这个图首先$2$通过$5$连到$4$上，花费$2$个$22$，然后$4$通过$2$连到$4$上，花费$1$个$22$，然后，$4$通过$4$连到$1$上花费$2$个$22$，然后$1$通过$4$连到$8$上，花费$1$个$22$，最后从$1$走到$8$花费$1$个$22$
这种是间接连接，$u$和$v$之间的连边变化情况：走$v$到$i$个路径让$u$连到$i$上，然后$v$和$i$相连之后，让$i$和$i$形成自环，然后让$i$和$1$与$n$连接，花费$i$到$1$和$i$到$n$的路径。最后再走一条边（运行时）
直接连接：$u$先连到$1$，然后$1$再连到$n$：$u$连到$1$走的时$v$到1的路径然后$1$连到$n$走的是$u$到$n$的路径，画个图就知道了
所以方程是：

// direct connect
		ans = min(ans, 1LL * w * (f[0][u] + f[v][n-1] + 1));
		ans = min(ans, 1LL * w * (f[0][v] + f[u][n-1] + 1));
		
		// indirect connect
		for (int k = 0; k < n; ++k) {
			ans = min(ans, 1LL * w * (f[v][k] + 1 + f[k][0] + f[k][n-1] + 1));
			ans = min(ans, 1LL * w * (f[u][k] + 1 + f[k][0] + f[k][n-1] + 1));
		}
 

以上思路参考文章：
参考文章
(AC代码）：

#include<iostream>
#include<cstdio>
#include<vector>
using namespace std;
#define min(a,b) ((a<b)?a:b)
typedef long long ll;
const int length = 505;
vector<pair<int, pair<int, int>>> edge;
int f[length][length];
int main(void)
{
	int t;
	scanf_s("%d", &t);
	for (int i = 0; i < t; i++)
	{
		edge.clear();
		int n, m;
		scanf_s("%d%d", &n, &m);
		for (int i = 1; i <= n; i++)
		{
			for (int j = 1; j <= n; j++)
			{
				if (i == j)f[i][j] = 0;
				else f[i][j] = INT_MAX>>1;
			}
		}
		for (int i = 0; i < m; i++)
		{
			int a, b, c;
			scanf_s("%d%d%d", &a, &b, &c);
			edge.push_back({ a,{b,c} });
			f[a][b] = 1;
			f[b][a] = 1;
		}
		for (int k = 1; k <= n; k++)
		{
			for (int i = 1; i <= n; i++)
			{
				for (int j = 1; j <= n; j++)
				{
					f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
				}
			}
		}
		ll ans = LLONG_MAX;
		for (int i = 0; i < m; i++)
		{
			int u = edge[i].first;
			int v = edge[i].second.first;
			int w = edge[i].second.second;
			//直接
			ans = min(ans, (ll)w*(f[u][1] + f[v][n] + 1));
			ans = min(ans, (ll)w*(f[v][1] + f[u][n] + 1));

			//间接
			for (int i = 1; i <= n; i++)
			{
				ans = min(ans, (ll)w*(f[u][i] + 1 + f[i][1] + f[i][n] + 1));
				ans = min(ans, (ll)w*(f[v][i] + 1 + f[i][1] + f[i][n] + 1));
			}
		}
		printf("%lld\n", ans);
	}
}

我写的沙雕代码：

#include<iostream>
#include<cstdio>
#include<vector>
#define min(a,b) ((a<b)?a:b)
using namespace std;
typedef long long ll;
class s
{
public:
	ll weight;
	ll cost;
	s()
	{

	}
	s(int yh)
	{
		weight = yh;
		cost = 0;
	}
	ll operator +( s a)
	{
		return 2*weight + cost + a.cost;
	}
	 
};

const int length = 505;
struct s linjie[length][length];
bool flag[length][length];
ll dp[length][length];
vector<int> s1;
vector<vector<int>> edge(length);
int vis[length];
int n;
ll res = LLONG_MAX;
void dfs(int cur, int fa)
{
	if (cur == n)
	{
		int yh1 = s1.size();
		for (int length = 2; length <yh1; length++)
		{
			for (int i = 0; i <yh1 - length; i++)
			{
				int j = i + length;
				int u = s1[i];
				int v = s1[j];
				ll yh = min(dp[u][v],linjie[u][v].weight+linjie[u][v].cost);//这个yh草率了
				for (int k = 1; k <= n; k++)
				{
					//if (!(flag[u][k] && flag[k][v]))continue;
					if ((linjie[u][k] + linjie[k][v] )< yh&&linjie[k][v].weight!=INT_MAX>>1)
					{
						linjie[u][v].weight = linjie[v][u].weight=linjie[u][k].weight;
						linjie[u][v].cost = linjie[v][u].cost=linjie[u][k].cost + linjie[k][v].cost+linjie[u][k].weight;
						
					}
					if ((linjie[v][k] + linjie[k][u]) < yh&&linjie[k][u].weight!=INT_MAX>>1)
					{
						linjie[u][v].weight = linjie[v][u].weight = linjie[v][k].weight;
						linjie[u][v].cost = linjie[v][u].cost = linjie[v][k].cost + linjie[k][u].cost+linjie[v][k].weight;
					}
				}
			}
		}
		res = min(res, linjie[1][n].weight+linjie[1][n].cost);
		return;
	}
	for (int i=1;i<=n;i++)
	{
		int v = i;
		if (!vis[v] && v != fa&&flag[cur][v])
		{
			s1.push_back(v);
			vis[v] = 1;
			dfs(v, cur);
			s1.pop_back();
			vis[v] = 0;
		}
	}
}
int main(void)
{
	int t;
	scanf_s("%d", &t);
	for (int i = 0; i < t; i++)
	{
		int m;
		scanf_s("%d%d", &n, &m);
		res = LLONG_MAX;
		for (int i = 1; i <= n; i++)
		{
			for (int j = 1; j <= n; j++)
			{
				linjie[i][j].weight = INT_MAX>>1;
				linjie[i][j].cost = 0;
				dp[i][j] = INT_MAX >> 1;
			}
		}
		for (int i = 0; i < m; i++)
		{
			int a, b, c;
			scanf_s("%d%d%d", &a, &b, &c);
			linjie[a][b].weight = min(linjie[a][b].weight,c);
			linjie[b][a].weight = min(linjie[b][a].weight,c);
			flag[a][b] = 1;
			flag[b][a] = 1;
			dp[a][b] = min(dp[a][b],c);
			dp[b][a] = min(dp[b][a],c);
		}
		for (int k = 1; k <= n; k++)
		{
			for (int i = 1; i <= n; i++)
			{
				for (int j = 1; j <= n; j++)
				{
					dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
				}
			}
		}
		vis[1] = 1;
		s1.push_back(1);
		for(int i=n-1;i>=1;i--)
	     	dfs(i, -1);
		printf("%lld\n", min(dp[1][n],res));
	}
}