Codeforces 1474F. 1 2 3 4 ... 题解

题目大意：给定一个序列，求其中最长严格上升子序列长度及其个数。

序列按如下方式给出：给定 \(n(1\leq n\leq 50)\) 和序列中的第一个数 \(x(-10^9\leq x\leq 10^9)\)，接下来 \(n\) 个数 \(d_i(-10^9\leq d_i\leq 10^9)\)，若 \(d_i>0\)，则重复 \(d_i\) 次，在序列末尾加上当前序列最后一个数 \(+1\) 的值，若 \(d_i<0\)，重复 \(-d_i\) 次，在序列末尾加上当前序列最后一个数 \(-1\) 的值。

---

题解：首先 \(x\) 没有任何用处，证明显然。

首先求最长上升子序列长度非常容易，直接 \(O(n^2)\) 暴力就可以了，具体来说，因为值是连续的，所以我们只需要知道一个最长上升子序列的最小值和最大值就可以知道它的长度了，那么这个地方直接枚举起点（容易发现一定在 \(d_i\) 做完的位置上），然后计算一下之后的最大值就可以了。

接下来的主要问题是如何求出最长上升子序列的方案数，容易发现如果构成最长上升子序列的最大值和最小值不唯一，那么这些最大值和最小值所在的区间一定不交，所以可以直接拆开来算，所以我们只需要考虑只有一种最小值和最大值的情况。

假设序列开头是最小值（这容易做到），那么我们就可以考虑 DP 了，设 \(f_{v,i}\) 表示当前的值是 \(v\)，当前所在的段是 \(i\)（段就是一整段上升或下降）的方案数，这个转移十分显然，并且容易发现在很大的一段区间内转移都是相同的，可以采用矩阵快速幂来优化。

不过还是需要特判一下 \(d_i\) 全部都是负数的情况。

时间复杂度：\(O(n^4\log A)\)（其中 \(A\) 是值域）。

代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
const int Maxn=50;
const int Mod=998244353;
int n;
int a[Maxn+5],a_len;
int m;
struct Matrix{
	int a[Maxn+5][Maxn+5];
	void init_zero(){
		for(int i=0;i<=m;i++){
			for(int j=0;j<=m;j++){
				a[i][j]=0;
			}
		}
	}
	void init(){
		for(int i=0;i<=m;i++){
			for(int j=0;j<=m;j++){
				a[i][j]=(i==j);
			}
		}
	}
	friend Matrix operator *(Matrix a,Matrix b){
		Matrix ans;
		ans.init_zero();
		for(int i=0;i<=m;i++){
			for(int k=0;k<=m;k++){
				for(int j=0;j<=m;j++){
					ans.a[i][j]=(ans.a[i][j]+1ll*a.a[i][k]*b.a[k][j])%Mod;
				}
			}
		}
		return ans;
	}
};
Matrix quick_power(Matrix a,int b){
	Matrix ans;
	ans.init();
	while(b){
		if(b&1){
			ans=ans*a;
		}
		b>>=1;
		a=a*a;
	}
	return ans;
}
struct Vector{
	int a[Maxn+5];
	void init_zero(){
		for(int i=0;i<=m;i++){
			a[i]=0;
		}
	}
	friend Vector operator *(Vector a,Matrix b){
		Vector ans;
		ans.init_zero();
		for(int i=0;i<=m;i++){
			for(int j=0;j<=m;j++){
				ans.a[j]=(ans.a[j]+1ll*a.a[i]*b.a[i][j])%Mod;
			}
		}
		return ans;
	}
};
struct Segment{
	ll l,r;
}seg[Maxn+5];
int seg_len;
ll d[Maxn*6+5];
int d_len;
int solve(int l,int r){
	m=r-l+1;
	seg_len=0;
	ll x=0;
	for(int i=l;i<=r;i++){
		seg_len++;
		seg[seg_len].l=(x+(a[i]<0?-1:1));
		seg[seg_len].r=x+a[i];
		x+=a[i];
	}
	seg[1].l=0;
	d_len=0;
	for(int i=1;i<=seg_len;i++){
		d[++d_len]=seg[i].l-1;
		d[++d_len]=seg[i].l;
		d[++d_len]=seg[i].l+1;
		d[++d_len]=seg[i].r-1;
		d[++d_len]=seg[i].r;
		d[++d_len]=seg[i].r+1;
	}
	sort(d+1,d+1+d_len);
	d_len=unique(d+1,d+1+d_len)-d-1;
	d_len--;
	Vector ans;
	ans.init_zero();
	ans.a[0]=1;
	ll lst=-1;
	for(int i=1;i<=d_len;i++){
		Matrix tmp;
		tmp.init_zero();
		for(int j=1;j<=seg_len;j++){
			if(min(seg[j].l,seg[j].r)<=lst+1&&max(seg[j].l,seg[j].r)>=d[i]){
				if(seg[j].l<seg[j].r){
					for(int k=0;k<=j;k++){
						tmp.a[k][j]=1;
					}
				}
				else{
					for(int k=0;k<j;k++){
						tmp.a[k][j]=1;
					}
				}
			}
		}
		tmp=quick_power(tmp,d[i]-lst);
		ans=ans*tmp;
		lst=d[i];
	}
	int sum=0;
	for(int i=0;i<=m;i++){
		sum=(sum+ans.a[i])%Mod;
	}
	return sum;
}
int main(){
	scanf("%d%*d",&n);
	for(int i=1;i<=n;i++){
		int x;
		scanf("%d",&x);
		if(x!=0){
			a[++a_len]=x;
		}
	}
	n=a_len;
	ll ans=0;
	ll sum=0;
	for(int i=1;i<=n;i++){
		ll tmp=sum;
		for(int j=i;j<=n;j++){
			tmp+=a[j];
			ans=max(ans,tmp-sum);
		}
		sum+=a[i];
	}
	if(ans==0){
		int val=1;
		for(int i=1;i<=n;i++){
			val=(val-a[i])%Mod;
		}
		printf("%lld %d\n",ans+1,val);
		return 0;
	}
	sum=0;
	int val=0;
	for(int i=1;i<=n;i++){
		ll tmp=sum;
		int right=-1;
		for(int j=i;j<=n;j++){
			tmp+=a[j];
			if(tmp-sum==ans){
				right=j;
			}
		}
		sum+=a[i];
		if(right!=-1){
			val=(val+solve(i,right))%Mod;
			i=right;
		}
	}
	printf("%lld %d\n",ans+1,val);
	return 0;
}