NOI Online #1 Starter Group T3 Magic

Original title link

Concise title

Find the shortest path, you can put the middle at most kkThe right of$k$ roads is changed to negative.

analysis:

It can be found that this question nnThe range of$n$ is very small, you can use$floyd$ to do it. $floyd$ find the shortest path on one side,$d(i,j)=\min \left(d\right(i,k)+d(k,j\left)\right)$ , after we find the shortest path, consider adding magic. Let$f(i,j,p)$ is$i$ to$j$ usesppThe shortest path of$p$ magic. A road can be changed to negative, then there is a state transition equation$$f(i,j,p)=\min \left(f\right(i,u,x)-edge(u,v)+f(v,j,and),x+Y=p)$$ Such a state transition equation space is not enough, and a four-level loop must be enumerated. If it is changed to a rolling array,$f(i,j)$ means$i$ tojjThe shortest path of$j$ . Regardless of how many times the magic is used, then:$$f(i,j)=\min \left(f\right(i,u)-edge(u,v)+f(v,j\left)\right)$$ So, let's consider using$K$ times magic problem. Obviously, each iteration will choose an edge to use magic or not, and not choosing will only be the optimal solution, so iterate$k$ times is at most$K-$ time magic solution. But this space is enough, but the time is still not enough, there is still a four-layer cycle.
Consider re-optimization, so calculate$K$ times, and this one uses magic every time you choose the side, but it doesn’t matter which side you choose first, so the associative law is satisfied. Then if the associative law is satisfied, it can be solved with fast power. Because$f$ is a two-dimensional array, you can use a method similar to matrix multiplication to find$min\; is$ fine. In this way, first calculate the solution using magic once, and then quickly exponentiate it to use$k$ times plan.
The time complexity of fast power is$\Theta \left(n^3\log n\right)$ ,dp dp infront$dp$ find the shortest path is$\Theta \left(n^3\right)$,$dp$ The time complexity of finding a magic is$\Theta \left(n^{2}m\right)$, the total time complexity is$\Theta (n^3\log n+n^{2}m)$。

Code:

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int NN=104;
int n,m,k;
ll d[NN][NN],f[NN][NN];
struct node
{
    
    
	int u,v,w;
}edge[2504];
void mul(ll c[][NN],ll a[][NN],ll b[][NN])
{
    
    
	ll t[NN][NN];
	memset(t,0x3f,sizeof(t));
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			for(int k=1;k<=n;k++)
				t[i][j]=min(t[i][j],a[i][k]+b[k][j]);
	memcpy(c,t,sizeof(t));
}
ll ksm()
{
    
    
	while(k)
	{
    
    
		if(k&1)
			mul(d,d,f);
		mul(f,f,f);
		k>>=1;
	}
	return d[1][n];
}
int main()
{
    
    
	scanf("%d%d%d",&n,&m,&k);
	memset(d,0x3f,sizeof(d));
	for(int i=1;i<=n;i++)
		d[i][i]=0;
	for(int i=0;i<m;i++)
	{
    
    
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		edge[i]=(node){
    
    u,v,w};
		d[u][v]=min(d[u][v],1ll*w);
	}
	for(int k=1;k<=n;k++)
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
	memcpy(f,d,sizeof(f));
	for(int k=0;k<m;k++)
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				f[i][j]=min(f[i][j],d[i][edge[k].u]-edge[k].w+d[edge[k].v][j]);
	printf("%lld",ksm());
	return 0;
}