[2020-11-30 contest]数列（矩阵加速），秘密通道（dijkstra最短路）小X游世界树（换根dp），划分（数学）

数列

a[1]=a[2]=a[3]=1 a[x]=a[x-3]+a[x-1] (x>3) 求 a 数列的第 n 项对 1000000007（10^9+7）取余的值。

输入格式
第一行一个整数 T，表示询问个数。 以下 T 行，每行一个正整数 n。

输出格式
每行输出一个非负整数表示答案。

样例
输入样例
3
6
8
10
输出样例
4
9
19
数据范围与提示
对于 30%的数据 n<=100； 对于 60%的数据 n<=2x10⁷
对于 100%的数据 T<=100，n<=2x10⁹

solution

一眼题，没得说

$$\left[\begin{array}{c}{a}_1,a_2,a_3\end{array}\right]\times \left[\begin{array}{ccc}0& 0& 1\\ 1& 0& 0\\ 0& 1& 1\end{array}\right]=\left[\begin{array}{c}{a}_2,a_3,a_4\end{array}\right]$$

code

#include <cstdio>
#include <cstring>
#define mod 1000000007
#define ll long long
struct Matrix {
	ll c[4][4];
	
	Matrix() {
		memset( c, 0, sizeof( c ) );
	}
	
	Matrix operator * ( const Matrix &p ) {
		Matrix ans;
		for( int i = 1;i <= 3;i ++ )
			for( int j = 1;j <= 3;j ++ )
				for( int k = 1;k <= 3;k ++ )
					ans.c[i][k] = ( ans.c[i][k] + c[i][j] * p.c[j][k] % mod ) % mod;
		return ans;
	}
	
}base, v, result;
int T, n;

Matrix qkpow( Matrix x, int y ) {
	Matrix res;
	res.c[1][1] = res.c[2][2] = res.c[3][3] = 1;
	while( y ) {
		if( y & 1 ) res = res * x;
		x = x * x;
		y >>= 1;
	}
	return res;
}

int main() {
	freopen( "seq.in", "r", stdin );
	freopen( "seq.out", "w", stdout );
	base.c[1][1] = base.c[1][2] = base.c[1][3] = 1;
	v.c[1][3] = v.c[2][1] = v.c[3][2] = v.c[3][3] = 1;
	scanf( "%d", &T );
	while( T -- ) {
		scanf( "%d", &n );
		if( n <= 3 ) {
			printf( "1\n" );
			continue;
		}
		result = base * qkpow( v, n - 3 );
		printf( "%lld\n", result.c[1][3] );
	}
	return 0;
}

秘密通道

有一副$n\times m$的地图，有$n\times m$块地，每块是下列四种中的一种： 墙：用#表示，墙有 4 个面，分别是前面，后面，左面，右面。 起点：用 C 表示，为主角的起点，是一片空地。 终点：用 F 表示，为主角的目的地，是一片空地。 空地：用 . 表示。 其中除了墙不能穿过，其他地方都能走。 主角有以下 3 种操作：

移动到相邻的前后左右的地方，花费一个单位时间。
向前后左右其中一个方向发射子弹，子弹沿直线穿过，打在最近的一堵墙的一面，然 后墙的这面就会形成一个开口通往秘密通道。同一时间最多只能有两个开口，若出现有 3 个 开口，出现时间最早的开口会立即消失。该操作不用时间。
可以从一个与开口相邻的空地跳进去，进入秘密通道，从另外一个开口正对的空地跳 出来。这个过程花费一个单位时间。 地图四周都是墙，问主角最少用多少时间从 C 走到 F。C 和 F 只会出现一次。
输入格式
第一行输入两个正整数 n，m。 接下来 n 行，每行 m 个字符描述地图。

输出格式
输出 1 个整数，表示最短时间完成路途。如果无解输出 nemoguce

样例
输入样例1
4 4

#.F#
#C.#

输出样例1
2
输入样例2
6 8
########
#.##…F#
#C.##…#
#…#…#
#…##
########
输出样例2
4
数据范围与提示
对于 50%的数据，4 ≤ 𝑛, 𝑚 ≤ 15。 对于 100%的数据，4 ≤ 𝑛, 𝑚 ≤ 500。

solution

两眼题
这种走迷宫条件反射就想上bfs，不过很明显⛏最短路
这道题还是很善良的，打枪是没有时间的，当然就算有也一样简单
但是考场上，我想错了，以为走到墙旁边的格子再打枪一定是最优的
然并卵👇

很明显，我首先就得往下打一枪，再往右走，打枪穿墙瞬移
于是我被卡了30′

所以，对于地图上的每一个点都有八条建边可能
四个方向相邻格子建边边权$1$
四个墙相邻格子建边均为四个方向上最近的墙的距离
$n\times m$个点，普通$O(n^2)dijkstra$整不动，就上堆优化

code

#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define maxn 505
struct node {
	int i, j, w;
	node(){}
	node( int I, int J, int W ) {
		i = I, j = J, w = W;
	}
	bool operator < ( const node &u ) const {
		return w > u.w;
	}
};
priority_queue < node > q;
int n, m;
char s[maxn][maxn];
bool vis[maxn][maxn];
int Up[maxn][maxn], Down[maxn][maxn], Left[maxn][maxn], Right[maxn][maxn];

bool inside( int x, int y ) {
	if( x < 1 || x > n || y < 1 || y > m ) return 0;
	else return 1;
}

void Push( int x, int y, int w ) {
	if( ! inside( x, y ) ) return;
	if( s[x][y] == '#' ) return;
	if( vis[x][y] ) return;
	q.push( node( x, y, w ) );
}

void Dijkstra() {
	while( ! q.empty() ) {
		node u = q.top(); q.pop();
		int i = u.i, j = u.j, w = u.w;
		if( vis[i][j] ) continue;
		if( s[i][j] == 'F' ) {
			printf( "%d\n", w );
			return;
		}
		vis[i][j] = 1;
		Push( i - 1, j, w + 1 );
		Push( i + 1, j, w + 1 );
		Push( i, j - 1, w + 1 );
		Push( i, j + 1, w + 1 );
		int minn = min( min( i - Up[i][j], Down[i][j] - i ), min( j - Left[i][j], Right[i][j] - j ) );
		Push( Up[i][j] + 1, j, w + minn );
		Push( Down[i][j] - 1, j, w + minn );
		Push( i, Left[i][j] + 1, w + minn );
		Push( i, Right[i][j] - 1, w + minn );
	}
	printf( "nemoguce\n" );
}

int main() {
	scanf( "%d %d", &n, &m );
	for( int i = 1;i <= n;i ++ ) {
		scanf( "%s", s[i] + 1 );
		for( int j = 1;j <= m;j ++ )
			if( s[i][j] == 'C' ) q.push( node( i, j, 0 ) );
	}
	for( int i = 1;i <= n;i ++ )
		for( int j = 1;j <= m;j ++ ) {
			if( s[i - 1][j] == '#' ) Up[i][j] = i - 1;
			else Up[i][j] = Up[i - 1][j];
			if( s[i][j - 1] == '#' ) Left[i][j] = j - 1;
			else Left[i][j] = Left[i][j - 1];
		}
	for( int i = n;i;i -- )
		for( int j = m;j;j -- ) {
			if( s[i + 1][j] == '#' ) Down[i][j] = i + 1;
			else Down[i][j] = Down[i + 1][j];
			if( s[i][j + 1] == '#' ) Right[i][j] = j + 1;
			else Right[i][j] = Right[i][j + 1];
		}
	Dijkstra();
	return 0;
}

小X游世界树

小 x 得到了一个(不可靠的)小道消息，传说中的神岛阿瓦隆在格陵兰海的某处,据说那 里埋藏着亚瑟王的宝藏，这引起了小 x 的好奇，但当他想前往阿瓦隆时发现那里只有圣诞节 时才能到达，然而现在已经春天了，不甘心的他将自己的目的地改成了世界树，他耗费了大 量的时间，终于将自己传送到了世界树下。世界树是一棵非常巨大的树，它有着许许多多的 枝条以及节点，每个节点上都有一个平台。好不容易来到传说中的世界树下，小 x 当然要爬 上去看看风景。小 x 每经过一条边都会耗费体力值。然而世界树之主想给他弄（gáo）些 （d ǐan）麻（shì）烦（qíng），于是他在每条边上都设了一个魔法阵，当小 x 踏上那条边时会 被传送回根节点，魔法阵只生效一次。这岂不是要累死小 x？幸运的是，每个平台上都有无 数个加速器，这些加速器可以让小 x 在当前节点所连的边上耗费的体力值减少，不同平台的 加速器性能不一定相同，但同一个平台的加速器性能绝对相同。世界树之主给了小 x 一次 “换根”的机会，他可以将世界树的任何一个节点变为根，但所有的边都不能改变。小 x 想 问你，将根换为哪个节点能使小 x 爬到世界树上的每个节点耗费的体力值和最少。默认编号 为 1 的点为初始根

输入格式
第一行一个数 n，表示有 n 个节点。 第二行 n 个数 ai，表示每个平台上的加速器的性能。 第三至 n+1 行，每行三个数 bi,ci,di 分别表示这条无向边的起点，终点与耗费的能量值。

输出格式
第一行一个数，表示要换成的节点，如果有多个点为根时耗费的体力值都最小，则输出 编号最小的那个。如果保持为 1 是最优的，就输出 1。 第二行一个数，表示最小耗费的体力值。

样例
输入样例
4
2 1 3 3
1 2 3
1 3 4
2 4 6
输出样例
1
9
数据范围与提示
如果以第一个点为根，则需要耗费 0(到 1)+1(到 2)+2(到 3)+6(到 4)=9 的能量值。 如果以第二个点为根，则需要耗费 2(到 1)+0(到 2)+4(到 3)+5(到 4)=11 的能量值。 如果以第三个点为根，则需要耗费 1(到 1)+2(到 2)+0(到 3)+7(到 4)=10 的能量值。 如果以第四个点为根，则需要耗费 5(到 1)+3(到 2)+7(到 3)+0(到 4)=15 的能量值。 很明显以第一个点为根是最优的。

对于 20%的数据:n<=100 对于 40%的数据:n<=1000 对于 60%的数据:n<=8000 对于 80%的数据:n<=100000 对于 100%的数据:0<n<=700000;ai<=1000;1<=bi,ci<=n;di<=1000。

solution

一眼题，没得跑，换根dp还是很裸的了
$g[u]$：$u$子树内每个点到$u$所耗费的体力值之和
$f[u]$：除$u$子树外所有点到$u$所耗费的体力值之和
很明显👇
$g[u]$与$u$儿子挂钩，需要从下往上更新
$f[u]$与$u$祖先挂钩，需要从上往下更新
所以两个分开用$dfs$⛏

然而我因为最后的极大值附小了，于是愉快地又爆掉了30′

code

#include <cstdio>
#include <vector>
using namespace std;
#define maxn 700005
#define ll long long
vector < pair < int, int > > G[maxn];
int n;
int a[maxn], siz[maxn];
ll f[maxn], g[maxn], ans[maxn];

void dfs1( int u, int fa ) {
	siz[u] = 1;
	for( int i = 0;i < G[u].size();i ++ ) {
		int v = G[u][i].first, w = G[u][i].second;
		if( v == fa ) continue;
		dfs1( v, u );
		siz[u] += siz[v];
		g[u] += g[v] + 1ll * siz[v] * ( w - a[u] );
	}
}

void dfs2( int u, int fa ) {
	for( int i = 0;i < G[u].size();i ++ ) {
		int v = G[u][i].first, w = G[u][i].second;
		if( v == fa ) continue;
		f[v] = f[u] + g[u] - g[v] - 1ll * siz[v] * ( w - a[u] ) + 1ll * ( n - siz[v] ) * ( w - a[v] );
		ans[v] = g[v] + f[v];
		dfs2( v, u );
	}
}

int main() {
	scanf( "%d", &n );
	for( int i = 1;i <= n;i ++ )
		scanf( "%d", &a[i] );
	for( int i = 1, u, v, w;i < n;i ++ ) {
		scanf( "%d %d %d", &u, &v, &w );
		G[u].push_back( make_pair( v, w ) );
		G[v].push_back( make_pair( u, w ) );
	}
	dfs1( 1, 0 );
	dfs2( 1, 0 );
	ll result = 1ll << 60; int pos;
	ans[1] = g[1];
	for( int i = 1;i <= n;i ++ )
		if( ans[i] < result ) result = ans[i], pos = i;
	printf( "%d\n%lld", pos, result );
	return 0;
}

划分

有一个未知的序列 x，长度为 n。它的 K-划分序列 y 指的是每连续 K 个数的和得到划 分序列，y[1]=x[1]+x[2]+…+x[K]，y[2]=x[K+1]+x[K+2]+…+x[K+K]…。 若 n 不被 K 整除，则 y[n/K+1]可以由少于 K 个数加起来。 比如 n=13，K=5，则 y[1]=x[1]+…+x[5]，y[2]=x[6]+…+x[10]，y[3]=x[11]+x[12]+ x[13]。若小 A 只确定 x 的 K[1]划分序列以及 K[2]划分序列…K[M]划分序列的值情况下， 问她可以确定 x 多少个元素的值。

输入格式
第一行输入两个正整数 n，M。 第二行输入 M 个正整数表示 K[1],K[2]…K[M]。

输出格式
输出 1 个整数，表示能确定的元素

样例
输入样例1
3 1
2
输出样例1
1
输入样例2
6 2
2 3
输出样例2
2
数据范围与提示
【样例解释】 【样例 1 解释】 小 A 知道 x 的 2-划分序列，即分别知道 x[1]+x[2]，x[3]的值。 小 A 可以知道 x[3]的值。 【样例 2 解释】 小 A 知道 x 的 2-划分序列，即分别知道 x[1]+x[2]，x[3]+x[4]，x[5]+x[6] 的值。 小 A 知道 x 的 3-划分序列，即分别知道 x[1]+x[2]+x[3] ，x[4]+x[5]+x[6] 的值。 小 A 可以知道 x[3],x[4]的值，个数为 2. 【数据范围】 对于 20%的数据，3 ≤ 𝑁 ≤ 2000, 𝑀 ≤ 3。 对于 40%的数据，3 ≤ 𝑁 ≤ 5 ∗ 10^6。 对于 100%的数据，3 ≤ 𝑁 ≤ 10^9, 1 ≤ 𝑀 ≤ 10，2 ≤ 𝐾[𝑖] < 𝑁。

solution

一眼题
一眼做不出来的题

首先很明显可以发现，若要确定$x$，当且仅当我们知道$S_x,S_{x-1}$
即$x=k_1\times a=k_2\times b+1=>k_1\times a-k_2\times b=1$

发现这个式子长得很像扩展欧几里得$ax+by=1$，当且仅当$gcd(a,b)=1$有解

求出最小正整数解$a_1,b_1$
则通解$a$为$a_1+p\times b_1,p\in Z$
去解一个不等式$p\times b_1\times k_i+a_1\ast b_1\le n$

要是真这么简单就欧儿啦
我们不仅可以很明显的发现有解的条件是相差为$1$，也能很明显地发现我们会算重
就算发现不了样例也会告诉你血的教训
容斥就好了，可我容斥不行啊！！

我们设$s_1$表示所有$a$集合，$s_2$表示所有$b$的方程。
这样每一个$k_i$只会存在于$s_1,s_2$或者都不存在。
这样枚举的复杂度是$O(3^m)$的
容斥系数就是$(-1{)}^{|A|+|B|}$ 推一推找找规律就知道了

这里涉及了同余方程的合并，就是他们的$lcm$

code

#include <cmath>
#include <cstdio>
#define int long long
#define maxm 15
#define maxn 60000
int n, m, ans;
int k[maxm], f[maxn];

int gcd( int x, int y ) {
	if( ! y ) return x;
	else return gcd( y, x % y );
}

int lcm( int x, int y ) {
	int d = gcd( x, y );
	return x / d * y;
}

int exgcd( int a, int b, int &x, int &y ) {
	if( ! b ) {
		x = 1, y = 0;
		return a;
	}
	else {
		int d = exgcd( b, a % b, y, x );
		y -= x * ( a / b );
		return d;
	}
}

int calc( int a, int b ) {
	int x, y;
	if( exgcd( a, b, x, y ) != 1 ) return 0;
	x = ( x % b + b ) % b;
	if( x * a > n ) return 0;
	else return ( n - x * a ) / ( a * b ) + 1;
}

void dfs( int s1, int s2, int x, int t1, int t2 ) {
	if( s1 > n || s2 > n ) return;
	if( x > m ) {
		if( ! t1 || ! t2 ) return;
		ans += ( ( t1 + t2 ) & 1 ? -1 : 1 ) * calc( s1, s2 );
		return;
	}
	dfs( lcm( s1, k[x] ), s2, x + 1, t1 + 1, t2 );
	dfs( s1, lcm( s2, k[x] ), x + 1, t1, t2 + 1 );
	dfs( s1, s2, x + 1, t1, t2 );
}

signed main() {
	scanf( "%lld %lld", &n, &m );
	for( int i = 1;i <= m;i ++ )
		scanf( "%lld", &k[i] );
	k[++ m] = n;
	dfs( 1, 1, 1, 0, 0 );
	printf( "%lld", ans );
	return 0;
}