21.10.9 test

T1 购票方案 \(\color{green}{100}\)

对于每个时间节点维护它作为每种票所能包含的最后一个点时，这种票的起始点位置，由于这个位置是单调的，所以类似双指针维护，\(O(KN)\) 维护出来后再做个简单 dp 就行了。复杂度 \(O(KN)\)。

code:

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define in read()
inline int read(){
	int p=0,f=1;
	char c=getchar();
	while(c>'9'||c<'0'){if(c=='-')f=-1;c=getchar();}
	while(c>='0'&&c<='9'){p=p*10+c-'0';c=getchar();}
	return p*f;
}
const int N=1e5+5;
const int K=505;
bool ss;
int last[N][K];
int n,k;
int t[N];
int num[K],cost[K];
int one;
int sum[N];
bool tt;
signed main(){
	freopen("buy.in","r",stdin);
	freopen("buy.out","w",stdout);
	n=in,k=in;
	for(int i=1;i<=n;i++)
		t[i]=in;
	for(int i=1;i<=k;i++)
		num[i]=in,cost[i]=in,last[0][k]=1;
	one=in;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=k;j++){
			last[i][j]=last[i-1][j];
			while(t[last[i][j]]+num[j]-1<t[i])
				last[i][j]++;
		}
	for(int i=1;i<=n;i++){
		sum[i]=sum[i-1]+one;
		for(int j=1;j<=k;j++)
			sum[i]=min(sum[i],sum[last[i][j]-1]+cost[j]);
		cout<<sum[i]-sum[i-1]<<'\n';
	}
	return 0;
}

---

T2 直线相交 \(\color{red}{55}\)

假做法拿到了 \(55\) ，众人的 dfs 拿了 \(80\)，良心出题人！

考虑分成 \(k\) 组，每组中的边互相平行。

正常的dp：

设 \(f[i][j]\) 表示前 \(i\) 条边，能否形成 \(j\) 个交点。枚举这一组的大小即可。

\(f[i][j]=f[i-k][j-(i-k)\times k]\)

状态数 \(n^3\)，转移的复杂度为 \(O(n)\)，所以总复杂度 \(O(n^4)\)

神仙dp:

如果把每两条边都有交点的状态成为全交，有 \(n*(n-1)/2\) 个交点，那么每组中如果有 \(k\) 条边，它就会对全交状态损失 \(k*(k-1)/2\) 个交点。所以我们尝试以损失作为 dp 的状态。

设 \(g[i]\) 表示比全交状态损失 \(i\) 个交点，至少需要的边数。

枚举当前组的大小 \(j\)，有

\(g[i]=min(j+g[i-j*(j-1)/2])\)

实现时可以从小到大枚举 \(i\) ，用 \(g[i]+j\) 更新 \(g[i+j*(j-1)/2]\)

状态数 \(n^2\) ，转移复杂度为 \(O(n)\) 所以总复杂度 \(O(n^3)\)

对于 \(N,M\)，当且仅当 \(g[n*(n-1)/2-M]\leq N\) 时成立。

对于"当"：考虑拿出 \(g[n*(n-1)/2-M]\) 构造出所需的损失，剩下每条作为一组，不会有损失。

code:

#include<bits/stdc++.h>
using namespace std;
#define in read()
inline int read(){
	int p=0,f=1;
	char c=getchar();
	while(c>'9'||c<'0'){if(c=='-')f=-1;c=getchar();}
	while(c>='0'&&c<='9'){p=p*10+c-'0';c=getchar();}
	return p*f;
}
const int M=2e5+5;
int T,g[M],n[M],m[M],maxn;
signed main(){
	T=in;
	for(int i=1;i<=T;i++)
		n[i]=in,m[i]=in,maxn=max(maxn,n[i]);
	memset(g,127,sizeof(g));g[0]=0;
	for(int i=0;i<=maxn*(maxn-1)/2;i++)
		for(int j=1;j<=maxn&&i+j*(j-1)/2<=maxn*(maxn-1)/2;j++)
			g[i+j*(j-1)/2]=min(g[i]+j,g[i+j*(j-1)/2]);
	for(int i=1;i<=T;i++)
		cout<<(m[i]<=n[i]*(n[i]-1)/2&&(g[n[i]*(n[i]-1)/2-m[i]]<=n[i]))<<'\n';
	return 0;
}

---

T3 记录数列 \(\color{red}{50}\)

神秘dp和容斥

---

T4 随机游走 \(\color{red}{50}\)

每条边期望经过的次数等于端点期望出发的次数除以度数，所以要求出每个端点期望的出发次数，也可以转化为求每个点的经过次数。具体的，如果出发点为 \(s\)，每个点期望出发次数为 \(f_i\)，度数为 \(d_i\)，同时每个点还有出现的概率 \(p_i\)，所以我们可以求出没有修改时的初始期望权值，通过：

\[f_u=\sum\dfrac{f_v}{d_v}+p_u,f_n=0
\]

高斯消元即可。那么一条边 \((u,v)\) 的贡献就是 \((\dfrac{f_u}{d_u}+\dfrac{f_v}{d_v})*w_{(u,v)}\)。

这一步是 \(O(n^3)\) 的。但如果出现权值被修改了呢？难道用 \(O(n^4)\) 吗

注意到在高斯消元中的系数矩阵是不会变的，只有最后一列 \(p\) 在修改后会更改。

所以我们令系数矩阵为 \(A\)，把高斯消元的这步记为 \(Af=p\)。

又注意到对于 \(p\) 的修改不会超过 \(N\) 次。

于是有一个 trick ：记第 \(i\) 次修改后的 \(p\) 为 \(p^i\)，那么我们先把所有 \(p\) 的修改预处理出来，然后拉到一个矩阵 \(B=\{p^0,p^1,p^2,\cdots,p^n\}\)，那么高斯消元的一步变成 \(Af=B\) ，对 \(A\) 求逆，于是有 \(f=A^{-1}B\) ，可以在 \(O(n^3)\) 的时间里把 \(f\) 矩阵求出来，每列对应每次修改。

高斯消元 \(O(N^3)\)，每次修改时枚举每条边 \(O(NM)\)，对于边权的修改发现可以 \(O(1)\) 做，所以算法总复杂度 \(O(N^3+NM+Q)\)。

其实不算很难的题，只是那个矩阵的 trick 没见过。

code:

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define in read()
inline int read(){
	int p=0,f=1;
	char c=getchar();
	while(c>'9'||c<'0'){if(c=='-')f=-1;c=getchar();}
	while(c>='0'&&c<='9'){p=p*10+c-'0';c=getchar();}
	return p*f;
}
const int N=505;
const int M=1e4+5;
const int Q=1e6+5;
const int mod=998244353;
int n;
inline int qpow(int a,int b){
	int ans=1;
	while(b){
		if(b&1)ans=ans*a%mod;
		a=a*a%mod;
		b>>=1;
	}
	return ans;
}
inline int inv(int x){return qpow(x,mod-2);}
struct matrix{
	int x,y;
	int a[N][N];
}A,B;
matrix operator*(const matrix &a,const matrix &b){
	matrix c;
	for(int i=1;i<=a.x;i++)
		for(int j=1;j<=b.y;j++)
			c.a[i][j]=0;
	c.x=a.x,c.y=b.y;
	for(int i=1;i<=a.x;i++)
		for(int j=1;j<=b.y;j++)
			for(int k=1;k<=a.y;k++)
				c.a[i][j]=(a.a[i][k]*b.a[k][j]%mod+c.a[i][j])%mod;
	return c;
}
matrix matinv(matrix &a){
	matrix c;c.x=n,c.y=n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			c.a[i][j]=(i==j);
	for(int i=1;i<=n;i++){
		int now=i;
		for(int j=i+1;j<=n;j++)
			if(a.a[j][i]>a.a[now][i])now=j;
		swap(a.a[i],a.a[now]);swap(c.a[i],c.a[now]);
		int div=inv(a.a[i][i]);
		for(int j=1;j<=n;j++)
			a.a[i][j]=a.a[i][j]*div%mod;
		for(int j=1;j<=n;j++)
			c.a[i][j]=c.a[i][j]*div%mod;
		for(int j=1;j<=n;j++){
			if(j==i)continue;
			div=a.a[j][i];
			for(int k=i;k<=n;k++)
				a.a[j][k]=(a.a[j][k]-div*a.a[i][k]%mod+mod)%mod;
			for(int k=1;k<=n;k++)
				c.a[j][k]=(c.a[j][k]-div*c.a[i][k]%mod+mod)%mod;
		}
	}
	return c;
}
int m,q;
int mp[N][N];
int a[N],suma,invsuma,d[N],invd[N];
int u[M],v[M],w[M];
struct que{
	int opt,x,y,z;
}req[Q];
inline int add(int x,int y){return (x+y)%mod;}
inline int mul(int x,int y){return x*y%mod;}
signed main(){
	n=in,m=in,q=in;
	for(int i=1;i<n;i++)
		a[i]=in,suma+=a[i];
	invsuma=inv(suma);
	for(int i=1;i<=m;i++)
		u[i]=in,v[i]=in,w[i]=in,
		mp[u[i]][v[i]]=mp[v[i]][u[i]]=i,
		d[u[i]]++,d[v[i]]++;
	for(int i=1;i<=n;i++)
		invd[i]=inv(d[i]);
	for(int i=1;i<=q;i++){
		req[i].opt=in;
		if(req[i].opt==1) req[i].x=in,req[i].y=in,req[i].z=in;
		else req[i].x=in,req[i].y=in;
	}
	A.x=n,A.y=n;
	for(int i=1;i<=m;i++)
		A.a[u[i]][v[i]]=-1*invd[v[i]],
		A.a[v[i]][u[i]]=-1*invd[u[i]];
	for(int i=1;i<=n;i++)
		A.a[n][i]=A.a[i][n]=0,A.a[i][i]=1;
	int tmp=1;
	for(int i=1;i<=n;i++)
		B.a[i][tmp]=a[i]*invsuma%mod;
	for(int i=1;i<=q;i++)
		if(req[i].opt==2){
			suma+=req[i].y-a[req[i].x];
			invsuma=inv(suma);
			a[req[i].x]=req[i].y;
			++tmp;
			for(int i=1;i<=n;i++)
				B.a[i][tmp]=a[i]*invsuma%mod;
		}
	B.x=n,B.y=tmp;
	A=matinv(A);
	B=A*B;
	int now=1,ans=0;
	for(int i=1;i<=m;i++)
		ans=add(mul(add(mul(B.a[u[i]][now],invd[u[i]]),mul(B.a[v[i]][now],invd[v[i]])),w[i]),ans);
	cout<<ans<<'\n';
	for(int i=1;i<=q;i++){
		if(req[i].opt==1){
			int x=req[i].x,y=req[i].y,z=req[i].z;
			ans=add(mul(add(mul(B.a[x][now],invd[x]),mul(B.a[y][now],invd[y])),add(z-w[mp[x][y]],mod)),ans);
			w[mp[x][y]]=z;
		}
		else{
			now++;ans=0;
			for(int i=1;i<=m;i++)
				ans=add(mul(add(mul(B.a[u[i]][now],invd[u[i]]),mul(B.a[v[i]][now],invd[v[i]])),w[i]),ans);
		}
		cout<<ans<<'\n';
	}
	return 0;
}

矩阵封装，哪个傻逼

---