[考试反思]1029csp-s模拟测试93：殇逝

停止！

思考，

回顾。

疑惑？

遗忘…

一直只是在匆忙的赶进度，实际上的确是一点也不扎实。

T1，裸的偏序，想了一个多小时什么也没想到，只打了$O(n^2)$

难道之前学的就这么白学了？

T2，简单dp，没有任何优化就扔了。

单调性优化做了无数次还是不会。

T3，暴力和部分分，部分分写错，暴力没取模。

90多场了啊，这些毛病还在犯，那么考试还有什么意义啊？

需要真正的反思与总结了，需要真正内化成自己的东西，才不是浑浑噩噩度日吧。

少说点废话吧。

T1：序列

求区间大于0，其实就是前缀和之后求$b[j] \geq b[i]$且$a[j] \geq a[i]$的最大$j-i$

看起来向一个三维偏序，但是题目保证有大于0的解，所以当$i \geq j$时并不会更新答案。

所以其实$i/j$这一维并不需要偏序，只用考虑$a/b$两个数组即可。

而$i/j$只是转移值，现在转化为二维偏序问题。

乍一下想动用各种数据结构，但是内存都开不下。

而偏序问题的一个技巧就是通过排序某一维来取消这一维的限制。所以维数-1。

然后就是一个一维偏序问题了，树状数组维护即可。

总的来说就是按$a$排序，将$b$离散化，树状数组维护$i/j$下标最小值即可。

 #include<cstdio>
 #include<algorithm>
 #include<map>
 using namespace std;
 #define ll long long
 map<ll,int>M;
 struct P{
     ll a;int b,p;
     friend bool operator<(P x,P y){
         return x.a<y.a||(x.a==y.a&&x.p<y.p);
     }
 }p[];
 long long a[],b[];int n,ans,cnt,t[];
 int read(){
     register int p=,nt=;register char ch=getchar();
     while(ch<''||ch>'')nt=ch=='-',ch=getchar();
     while(ch>=''&&ch<='')p=(p<<)+(p<<)+ch-'',ch=getchar();
     return nt?-p:p;
 }
 void set(int p,int w){for(;p<=;p+=p&-p)t[p]=min(t[p],w);}
 int ask(int p,int w=){for(;p;p^=p&-p)w=min(w,t[p]);return w;}
 int main(){//freopen("sequence.in","r",stdin);
     n=read();M[];
     for(int i=;i<=n;++i)a[i]=a[i-]+read();
     for(int i=;i<=n;++i)b[i]=b[i-]+read(),M[b[i]];
     for(map<ll,int>::iterator it=M.begin();it!=M.end();it++)(*it).second=++cnt;
     for(int i=;i<=n;++i)p[i]=(P){a[i],M[b[i]],i};
     sort(p,p++n);
     for(int i=;i<=;++i)t[i]=;
     for(int i=;i<=n;++i)ans=max(ans,p[i].p-ask(p[i].b)),set(p[i].b,p[i].p);
     printf("%d\n",ans);
 }

T2：二叉搜索树

简单的$dp$就是$dp[i][j]$表示区间$[i,j]$之间的点形成树的代价，转移很简单：

$dp[i][j]=min(dp[i][k-1]+dp[k][j]+x[j]-x[i-1])$

其中x是权值的前缀和。

考虑优化：当你在某一个区间右端添加一个点的时候，你最后选定的根节点一定不会左移。

同理，你在左段添加一个点的话，最后选定的最优根节点也一定不会左移。

设$rt[i][j]$表示区间$[i,j]$的最优根节点。那么有

$rt[i][j-1] \leq rt[i][j] \leq rt[i+1][j]$

所以就可以dp了，用上面这个限制一下左右端点。

因为是单调的，所以在$n$种长度里每个位置平均只会被扫$O(n)$次。

所以总的复杂度是$O(n^2)$

 #include<cstdio>
 int n;long long x[],dp[][],rt[][];
 main(){
     scanf("%d",&n);
     for(int i=;i<=n;++i)scanf("%lld",&x[i]),x[i]+=x[i-];
     for(int l=;l<=n;++l)for(int r=l;r<=n;++r)dp[l][r]=;
     for(int l=;l<=n;++l)dp[l][l]=x[l]-x[l-],rt[l][l]=l;
     for(int L=;L<n;++L)for(int l=,r=l+L;r<=n;++l,++r)
         for(int m=rt[l][l+L-];m<=rt[r-L+][r];++m)
             if(dp[l][m-]+dp[m+][r]+x[r]-x[l-]<dp[l][r])
                 dp[l][r]=dp[l][m-]+dp[m+][r]+x[r]-x[l-],rt[l][r]=m;
     printf("%lld\n",dp[][n]);
 }

T3：走路

题面差评。非得让我栽$n-1$个跟头干啥？？？做个题结果就真栽跟头了。

挺神仙的一道题。这种分治思想很巧妙。

之前有一道题好像叫《$Dash \ Speed$》是线段树结构的分治，这个也差不多。。。

我们考虑暴力做法。

因为我对期望的理解直到今天$LNC$好好地给我来了一遍才深刻一点。

因为正着推的时候它的转移概率之和不一定为1，而期望的实际含义则是加权平均数。

所以正着推的话要想得到期望就还得一直带着概率算，在出环的图里不可做。

所以要倒着推：设$f_i$表示期望再经过几步才能到$k$点。

转移就是$f_i=\sum\limits_{i \to j}\frac{f_j}{degree_i}$

$degree_i$表是i的出度。

这样的话转移的总概率就是每一条出边累加$\frac{1}{degree_i}$那么总概率当然是1。

而正着的式子却不是，不再赘述。

暴力的思路就是拆掉每个点的所有出边，然后做一次瓜丝消元$f_1$就是解。

 #include<cstdio>
 #include<algorithm>
 using namespace std;
 #define mod 998244353
 #define ll long long
 int n,m,cnt[][],deg[],spj1=,spj2=;ll x[][],inv[],escape[];
 ll pow(ll b,int t=mod-,ll a=){for(;t;t>>=,b=b*b%mod)if(t&)a=a*b%mod;return a;}
 void Gauss(){
     for(int i=;i<=n;++i){
         if(!x[i][i])for(int j=i+;j<=n;++j)if(x[j][i])swap(x[i],x[j]);
         int inv=pow(x[i][i]);
         for(int j=i;j<=n+;++j)x[i][j]=x[i][j]*inv%mod;
         for(int j=i+;j<=n;++j)for(int k=n+;k>=i;--k)x[j][k]=(x[j][k]-x[i][k]*x[j][i]%mod+mod)%mod;
     }
     for(int i=n;i;--i)for(int j=i-;j;--j)x[j][n+]=(x[j][n+]-x[j][i]*x[i][n+]%mod+mod)%mod;
 }
 main(){
     scanf("%d%d",&n,&m);
     for(int i=,X,Y;i<=m;++i){
         scanf("%d%d",&X,&Y),deg[X]++,cnt[X][Y]++;
         if(i!=m&&X>Y)spj1=;
         if(X!=Y&&X!=&&Y!=)spj2=;
     }
     for(int i=;i<=m;++i)inv[i]=pow(i);
     for(int A=;A<=n;++A){
         for(int i=;i<=n;++i)for(int j=;j<=n+;++j)x[i][j]=;
         for(int i=;i<=n;++i)if(A!=i)for(int j=;j<=n;++j)x[j][i]=cnt[i][j]*inv[deg[i]]%mod;
         for(int i=;i<=n;++i)x[i][i]--;x[][n+]=-;
         //for(int i=1;i<=n;++i,puts(""))for(int j=1;j<=n+1;++j)printf("%lld ",x[i][j]);
         Gauss();for(int i=;i<=n;++i)if(i!=A)x[A][n+]+=x[i][n+];
         printf("%lld\n",x[A][n+]%mod-);
     }
 }

不难发现，我们再每一次重造矩阵的时候，其实只有一行是不一样的，就是你单独考虑的$k$那一行。

考虑这个问题：我在瓜丝消元的时候填了一行，然后这一行一直在被消来消去，但是我们始终不用这一行来消其它的行。

那么最后求出的解当然是不会变的对吧？

所以我们先不拆任何边，这样建出一个矩阵。

然后我们对于目前要处理出的k，把这一行看成我们乱加的那一行，这行怎么被消都没有关系，但是我们不能用这一行去消其它行。

这样的话就相当与我们没有加这一堆边，它们对答案没有影响。

考虑递归解决，$solve(l,r)$表示我们正在处理$[l,r]$之内的k。

那么如果k在$[l,mid]$里面，那么$[mid+1,r]$里面的所有边都要生效，就是这些行都要被当作主元来给其它行消元。

消完之后我们就可以递归求解$solve(l,mid)$了。

这样的话如果我们可以发现，$solve(l,r)$的时候其实除了$[l,r]$以外的区间都被当成主元消过了。

那么如果我们递归到了某一个叶节点，那么就是除了这一行以外所有的行都被消过了。

这就和我上面说的情况一致了，这样就可以解出当前点的答案了。

当然如果我们要求解$solve(mid+1,r)$时，我们就需要用$[l,mid]$的边消元。

在这之前我们首先需要把矩阵还原，开数组存一下就好了。

为了方便，我们在每一次消元的时候，并不是把它消成上三角矩阵，而是消成单位矩阵，这样在后面方程比较好解，不用回代。

要注意：如果你的代码递归处函数出现了2个$n$级别的循环而不是$[l,r]$的循环，那么你的复杂度就是$O(n^3 \ log \ n)$了。并不是正解。

而如果只有一个$n$级别的循环，那么你的复杂度就是$O(n^3)$

证明稍后写吧。

问题就在于你的迭代式是下面的哪个：

$T(n)=Nn^2+2T(\frac{n}{2})$

$T(n)=N^2n+2T(\frac{n}{2})$

其中N是指题目输入的N，而n是指当前递归区间的大小。

当然在计算复杂度的时候可以把$N$直接提出，那么第一个式子就是：

$T(n)=N \times t(n) $

$t(n)=n^2+2t(\frac{n}{2})$

根据主定理，得到$t(n)=n^2$

所以$T(n)=n^3$

而对于第二个式子，其复杂度为：

$T(n)=N^2 \times t(n)$

$t(n)=n+2t(\frac{n}{2})$

这是一个非常常见的分治复杂度了。根据常识或者根据主定理，$t(n)=n\  log \ n $

所以$T(n)=n^3 \  log \ n$

 #include<cstdio>
 #include<algorithm>
 using namespace std;
 #define mod 998244353
 #define int long long
 int n,m,cnt[][],deg[],x[][],inv[],ans[];
 int pow(int b,int t=mod-,int a=){for(;t;t>>=,b=b*b%mod)if(t&)a=a*b%mod;return a;}
 void Gauss(int l,int r,int L,int R){
     for(int i=L;i<=R;++i){
         int inv=pow(x[i][i]);
         for(int j=l;j<=r;++j)x[i][j]=x[i][j]*inv%mod;x[i][]=x[i][]*inv%mod;
         for(int j=;j<=n;++j)if(i!=j){
             int t=x[j][i];
             for(int k=l;k<=r;++k)x[j][k]=(x[j][k]-x[i][k]*t%mod+mod)%mod;
             x[j][]=(x[j][]-x[i][]*t%mod+mod)%mod;
         }
     }
 }
 void solve(int l,int r){
     if(l==r)return ans[l]=(mod+x[][])%mod,(void);
     int m=l+r>>;int re[][];
     for(int i=;i<=n;++i){for(int j=l;j<=r;++j)re[i][j]=x[i][j];re[i][]=x[i][];}
     Gauss(l,r,l,m);solve(m+,r);
     for(int i=;i<=n;++i){for(int j=l;j<=r;++j)x[i][j]=re[i][j];x[i][]=re[i][];}
     Gauss(l,r,m+,r);solve(l,m);
     for(int i=;i<=n;++i){for(int j=l;j<=r;++j)x[i][j]=re[i][j];x[i][]=re[i][];}
 }
 main(){
     scanf("%lld%lld",&n,&m);
     for(int i=,X,Y;i<=m;++i)scanf("%lld%lld",&X,&Y),deg[X]++,cnt[X][Y]++;
     for(int i=;i<=m;++i)inv[i]=pow(i);
     for(int i=;i<=n;++i)for(int j=;j<=n;++j)x[i][j]=cnt[i][j]*inv[deg[i]]%mod;
     for(int i=;i<=n;++i)x[i][i]--,x[i][]=-;
     solve(,n);for(int i=;i<=n;++i)printf("%lld\n",ans[i]);
 }