[NOI2020]美食家
题目
点这里看题目。
分析
NOI 里面也有我会做的题目？
显然不能把 \(T\) 放到状态里面，于是考虑用活动作为状态。
\(f(u,i)\)：第 \(i\) 个活动开始的时候，位于 \(u\) 城市的最大愉悦值。
转移如下：
其中 \(g(v,u,k)\) 表示用 \(k\) 的时间从 \(v\) 走到 \(u\) 的最大愉悦值。
然后继续发现 \(g\) 的转移：
然后发现这个转移非常的矩阵乘法，于是考虑将 \(g(...,...,t)\) 用矩阵表述出来，设之为 \(G_t\) 。
但是这里有一个小小的问题：常规的矩阵乘法，处理的图都是不带边权的。这道题中该怎么处理边权呢？
答案是：拆点。对于一个点，我们将它拆成 5 个点，表示在这个点上走了 0 步、1 步、 2 步 ...... 的状态。这样一条权为 \(w\) 的边就可以被拆成 \(w\) 条权为 1 的边，我们就可以在这个图上做矩阵乘法了。
我觉得学过关于图的矩阵乘的朋友都应该知道这个技巧吧。这里就咕掉细节了。
好，拆完点之后我们就真的可以用 \(G_t\) 来描述 \(g(...,...,t)\) 了。
继续观察转移发现有：
于是就有：
于是 \(G_t\) 就是 \(G_1\) 的幂，于是就可以想到预处理 \(G_1\) 的 \(2^k\) 次幂。于是我们就可以快速地得到 \(G_1\) 的幂。
回来看 \(f\) 的转移，我们发现 ...... 它还是很像一个向量乘以一个矩阵。
于是我们就可以直接用 \(\vec{F_k}\) 表示 \(f(...,k)\) ，然后转移就变成了：
对于 \(u=x_i\) 的情况，我们需要在乘法之后单独处理一下。
此时如果暴力搞到 \(G_1^{t_k-t_{k-1}}\) 就得到 \(O((nw)^3k\log_2T)\) 的优秀复杂度。不过 NOI Online 里面的技巧可以直接套过来：利用矩阵的结合律，我们直接用 \(\vec{F}\) 去分别乘 \(G_1\) 的倍增幂。于是就优化到了 \(O((nw)^2k\log_2T)\) ，足以通过本题。
本题的一些有价值的点：
- 带边权的图结合矩阵的拆点技巧。
- 向量乘矩阵幂的优化技巧。
代码
#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>
typedef long long LL;
const LL INF = -0xc0c0c0c0c0c0c0c0;
const int MAXS = 255;
const int MAXM = 510, MAXLOG = 35;
template<typename _T>
void read( _T &x )
{
x = 0;char s = getchar();int f = 1;
while( s > '9' || s < '0' ){if( s == '-' ) f = -1; s = getchar();}
while( s >= '0' && s <= '9' ){x = ( x << 3 ) + ( x << 1 ) + ( s - '0' ), s = getchar();}
x *= f;
}
template<typename _T>
void write( _T x )
{
if( x < 0 ){ putchar( '-' ); x = ( ~ x ) + 1; }
if( 9 < x ){ write( x / 10 ); }
putchar( x % 10 + '0' );
}
template<typename _T>
_T MAX( const _T a, const _T b )
{
return a > b ? a : b;
}
struct matrix
{
LL mat[MAXS][MAXS];
int n, m;
matrix() { n = m = 0, memset( mat, 0xc0, sizeof mat ); }
matrix( const int N ) { n = m = N, memset( mat, 0xc0, sizeof mat ); }
matrix( const int N, const int M ) { n = N, m = M, memset( mat, 0xc0, sizeof mat ); }
LL* operator [] ( const int indx ) { return mat[indx]; }
matrix operator * ( matrix b ) const
{
matrix ret( n, b.m );
for( int i = 1 ; i <= n ; i ++ )
for( int k = 1 ; k <= m ; k ++ )
if( mat[i][k] > -INF )
for( int j = 1 ; j <= ret.m ; j ++ )
ret[i][j] = MAX( ret[i][j], mat[i][k] + b[k][j] );
return ret;
}
void operator *= ( matrix b ) { *this = *this * b; }
};
struct festival
{
int t, x, y;
festival() { t = x = y = 0; }
festival( const int T, const int X, const int Y ) { t = T, x = X, y = Y; }
bool operator < ( const festival &b ) const { return t < b.t; }
}F[MAXM];
matrix G[MAXLOG];
matrix dp;
int fr[MAXM], to[MAXM], W[MAXM];
int C[MAXM], mx[MAXM] = {}, id[MAXM];
int N, M, K, T, tot = 1, lg2;
void upt( LL &x, const LL v ) { x = MAX( x, v ); }
void addEdge( const int u, const int v, const LL w ) { upt( G[0][u][v], w ); }
void init()
{
std :: sort( F + 1, F + 1 + K );
for( int i = 1 ; i <= N ; i ++ ) id[i] = tot, tot += mx[i];
-- tot, G[0] = matrix( tot, tot );
for( int i = 1 ; i <= N ; i ++ )
for( int j = 0 ; j < mx[i] - 1 ; j ++ )
addEdge( id[i] + j, id[i] + j + 1, 0 );
for( int i = 1 ; i <= M ; i ++ ) addEdge( id[fr[i]] + W[i] - 1, id[to[i]], C[to[i]] );
lg2 = log2( T );
for( int i = 1 ; i <= lg2 ; i ++ ) G[i] = G[i - 1] * G[i - 1];
}
int main()
{
read( N ), read( M ), read( T ), read( K );
for( int i = 1 ; i <= N ; i ++ ) read( C[i] );
for( int i = 1 ; i <= M ; i ++ ) read( fr[i] ), read( to[i] ), read( W[i] ), mx[fr[i]] = MAX( mx[fr[i]], W[i] );
for( int i = 1 ; i <= K ; i ++ ) read( F[i].t ), read( F[i].x ), read( F[i].y );
F[++ K] = festival( T, 1, 0 );
init();
dp = matrix( 1, tot ), dp[1][id[1]] = C[1];
for( int i = 1 ; i <= K ; i ++ )
{
int stp = F[i].t - F[i - 1].t;
for( int k = lg2 ; ~ k ; k -- )
if( stp & ( 1ll << k ) )
dp *= G[k];
dp[1][id[F[i].x]] += F[i].y;
}
LL ans = dp[1][id[1]];
if( ans < 0 ) puts( "-1" );
else write( ans ), putchar( '\n' );
return 0;
}
