[NOIP 2020] 微信步数

一、题目

二、题目

首先感谢一下这位大佬的博客，虽然我看不懂您的讲解，但是还是读得懂代码的

思路是 $\tt jys$ 给我讲明白的，首先我们可以感觉到快速计算它肯定和矩形有关系，也就是满足某种条件的情况一定在某个矩形中，虽然很抽象，但是我们能大概感觉到这道题的核心思路是 乘法原理

要求的是步数，其实相当于方案数加权，在它不太好算的情况下我们来考虑算方案数。我们记录某一维已经走过的步往左最多走了 $l$（是负数），往右最多走了 $r$ ，那么一维暂时不会走出去的位置数量可以表示成可以表示成 $m[i]=w[i]-r[i]+l[i]$，那么这种情况下不会走出去的方案数是：

\[\sum_{t=0}^{lim}\prod_{i=1}^k m[i]-t\times dt[i]
\]

其中 $dt[i]$ 是第 $i$ 维经过一轮的变化量，$lim$ 是一个上界表示走了 $lim$ 轮以后再走就出去了，所以只能够枚举到它，现实告诉我们不能枚举轮数，所以必须要优化。从多项式的角度看，我们把轮数当前自变量去推他的多项式

\[\sum_{i=0}^k dp[i]\times\sum_{t=0}^{lim} t^i
\]

$dp[i]$ 就是把所有 $-dt[i]\times t+m[i]$ 乘起来得到的多项式系数，我们把 $t$ 看作了自变量，但是系数是一定的。求系数可以暴力多项式乘法（应该不会有人写 $\tt fft$），后面的那个东西是老套路的，你去搜 [TJOI]教科书般的亵渎 就会找到一堆方法，我推荐 $yyb$ 这种用第二类斯特林数的做法（省选不是考烂了）：不会点此看。这样就很舒服了，算这个方案数是 $O(k^2)$ 的嗯。

然后我们枚举是第 $i$ 步走了出去，可以用差分，也就是第 $i-1$ 步没有走出去的方案数减去第 $i$ 步走出去的方案数，再乘上 $i$ 就是消耗的步数。

但是还没有考虑大轮的贡献啊，考虑上面我们的计算方式，其本质是前缀和，在第 $i$ 轮走出去的方案数会在 $t\in [0,i)$ 时都被算一遍，所以我们直接算一遍方案数然后乘上 $n$ 就可以了。

$\tt Unfortunately,$ 第一轮之内是需要单独讨论的，但只是增加了实现的难度，对整体算法影响不大，时间复杂度 $O(nk^2)$

#include <cstdio>

#include <iostream>

using namespace std;

const int M = 15;

const int N = 500005;

const int MOD = 1e9+7;

#define int long long

int read()

{

	int x=0,f=1;char c;

	while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}

	while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}

	return x*f;

}

int n,k,inv[M],s[M][M],w[M],a[M],dt[M];

int ans,c[N],d[N],l[M],r[M],z[M];

int Abs(int x)

{

	if(x>0) return x;

	return -x;

}

int walk(int x,int y)//x维上走一步

{

    z[x]+=y;

    if(l[x]>z[x] || r[x]<z[x])

    {

        l[x]=min(l[x],z[x]);

        r[x]=max(r[x],z[x]);

        return 1;

    }

    return 0;

}

void init(int k)

{

	s[0][0]=inv[0]=inv[1]=1;

	for(int i=1;i<=k;i++)//第二类斯特林数

		for(int j=1;j<=k;j++)

			s[i][j]=(s[i-1][j-1]+s[i-1][j]*j)%MOD;

	for(int i=2;i<=k+1;i++)

		inv[i]=(MOD-MOD/i)*inv[MOD%i]%MOD;

}

int cal(int k,int n)//这里的n其实是开区间

{

	int sum=0,C=1;

	for(int i=0;i<=k;i++)//C(n,i+1)*i!*s[k][i]

	{

		C=C*max(0ll,n-i)%MOD;

		sum=(sum+C*inv[i+1]%MOD*s[k][i])%MOD;

	}

	return sum;

}

int work()

{

	int lim=MOD,res=0;

	for(int i=1;i<=k;i++)

		if(dt[i]) lim=min(lim,(a[i]+dt[i]-1)/dt[i]);

    int dp[M]={1};

    for(int i=1;i<=k;i++)//暴力多项式乘法

        for(int j=i;j>=0;j--)

        {

            dp[j+1]=(dp[j+1]-dt[i]*dp[j])%MOD;

            dp[j]=dp[j]*a[i]%MOD;

        }

    for(int i=0;i<=k;i++)

        res=(res+dp[i]*cal(i,lim))%MOD;

    return res;

}

signed main()

{

	n=read();k=read();

	init(k);

	for(int i=1;i<=k;i++)

        w[i]=read();

    for(int i=1;i<=n;i++)

    {

        c[i]=read();d[i]=read();

        if(walk(c[i],d[i]) && r[c[i]]-l[c[i]]<=w[c[i]])

        //第二个判断很重要，因为要保证可能在这一步走出去

        {

            int x=1;

            for(int j=1;j<=k;j++)

                if(j!=c[i])

                    x=(x*max(0ll,w[j]-r[j]+l[j]))%MOD;

            ans=(ans+i*x)%MOD;//要在这里走出去只有一种选择

        }

    }

    int fl=1;

    for(int i=1;i<=k;i++)

    {

        fl&=(z[i]==0);

        dt[i]=Abs(z[i]);//别忘了

    }

    if(fl==1)

    {

        for(int i=1;i<=k;i++)

            fl|=(r[i]-l[i]>=w[i]);

        if(fl) puts("-1");

        else printf("%lld\n",ans);

        return 0;

    }

    for(int i=1;i<=k;i++)

        a[i]=max(0ll,w[i]-r[i]+l[i]);

    ans=(ans+n*work())%MOD;//第一部分贡献

    for(int i=1;i<=n;i++)//第二部分贡献

        if(walk(c[i],d[i]) && r[c[i]]-l[c[i]]<=w[c[i]])

        {

        	fl=1;

			for(int j=1;j<=k;j++)

				if(j!=c[i])

					fl&=(w[j]-r[j]+l[j]>0);

			if(!fl) continue;

            for(int j=0;j<k;j++)

            	if(j!=c[i]) a[j]=max(0ll,w[j]-r[j]+l[j]);

            a[c[i]]=w[c[i]]-r[c[i]]+l[c[i]]+1;//差分差分

            ans=(ans+i*work())%MOD;

            a[c[i]]=w[c[i]]-r[c[i]]+l[c[i]];

            ans=(ans-i*work())%MOD;

        }

    printf("%lld\n",(ans+MOD)%MOD);

}