Codeforces Round #501 (Div. 3) D~F

这套题的D，F都让我非常受启发，算法是美的啊。

D

让你在一个1~n的轴上走，从$x$->$y$的代价是$|x-y|$ 然后给出轴的长度和要走的步数，构造出一个代价恰好为s的行走方案。初始位置在1。每一步不可以不走（即不可以留在相同位置）

大概算法都很容易想到，先尽量走多的，比如说1->n->1这样，但是后来可能会出现每次走1的代价都超了的情况，这时需要控制一个阈值，走多少次完整的轴。这样想了之后我就去二分这个值，然后算出剩下要走多少，构造方案。现在想来的话，比如完整的轴走了k次，应该是最大化第k+1次然后剩下的都走1。就算是这样，这个构造方法也是略显麻烦，题解让我耳目一新。
每次直接走，假设走k步能使 剩下的步数都走1这一方案 满足条件（k没有限制不一定小于n），那么每次走min(k,n-1)就是可以的了。。。技不如人啊。规划的太好也不行，走一步看一步。

E

定义了一种”星“的形状，让你找出给出的矩形里有多少个星以及每个星的大小。

算是一个基础的矩阵题目，矩阵题目基本上就是各种奇怪的n方预处理，像什么最大子矩阵和，有障碍的情况下找最大矩形之类的。这题也是类似的，先预处理出对于每个点，上下左右连续最长的‘*’有多长，这个最多四遍遍历随便跑。然后遍历一次矩形，在这四个值中取min，就是这个点的最大星形。

有一个地方需要需要注意，-1的情况，是所找出来的星不能将 ‘*’ 完全覆盖就输出-1，也就是有一个 ‘*’ 不属于任何一个星那么输出-1，这个我的第一反应是一个差分，横纵各维护一个差分数组，就非常好做了。（刚看了一下题解发现也是这么做的233）

//QWsin
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define rep(i,x,y) for(int i=x;i<=y;++i)
#define out(i,u) for(int i=first[u];i!=-1;i=next[i])
using namespace std;

const int INF=1<<30;

const int maxn=1000+10;

char mx[maxn][maxn]; 
int up[maxn][maxn],dn[maxn][maxn],lft[maxn][maxn],rgh[maxn][maxn];
int c1[maxn][maxn],c2[maxn][maxn];

int main()
{
    int n,m;cin>>n>>m;

    rep(i,1,n) scanf("%s",mx[i]+1);

    rep(j,1,m) rep(i,1,n)
        if(mx[i][j]=='*') up[i][j]=up[i-1][j]+1;    
        else up[i][j]=0;

    rep(j,1,m) for(int i=n;i>=1;--i) 
        if(mx[i][j]=='*') dn[i][j]=dn[i+1][j]+1;
        else dn[i][j]=0;

    rep(i,1,n) rep(j,1,m) 
        if(mx[i][j]=='*') lft[i][j]=lft[i][j-1]+1;
        else lft[i][j]=0;

    rep(i,1,n) for(int j=m;j>=1;--j) 
        if(mx[i][j]=='*') rgh[i][j]=rgh[i][j+1]+1;
        else rgh[i][j]=0;

    int ok=1,c=0;

    rep(i,1,n) rep(j,1,m)
    {
        int k=min(min(up[i][j],dn[i][j]),min(lft[i][j],rgh[i][j]));
        if(k>1){
            ++c;
            ++c1[i][j-k+1];
            --c1[i][j+k];
            ++c2[i-k+1][j];
            --c2[i+k][j];
        }
    }

    rep(i,1,n) rep(j,1,m) c1[i][j]+=c1[i][j-1];
    rep(j,1,m) rep(i,1,n) c2[i][j]+=c2[i-1][j];
    rep(i,1,n) rep(j,1,m) c1[i][j] |= c2[i][j];

    rep(i,1,n) rep(j,1,m) if(mx[i][j]=='*' && !c1[i][j] ) ok=0;

    if(!ok) puts("-1");
    else{
        cout<<c<<endl;
        rep(i,1,n) rep(j,1,m)
        {
            int k=min(min(up[i][j],dn[i][j]),min(lft[i][j],rgh[i][j]));
            if(k>1){
                printf("%d %d %d\n",i,j,k-1);
            }
        }
    }

    return 0;
}

F

计数题，计算长度为$2n$的括号序列中，连续子序列包含$s$的有多少个。$\mod 1e9+7$

先用kmp或者暴力构造fail数组，然后像AC自动机一样算出每个位置填上’(’ 和’)’应该转移到哪里（我是将这两个符号变为1，0便于操作）
用$dp[i][j][k][l]$表示当前在第$i$个括号，在$s$的第$j$位，未匹配的左括号有$k$个（肯定不可能有未匹配的右括号），$l=0,1$表示是否出现了$s$。

转移从当前状态枚举填什么然后转移到下一位会比较好做。
$i$这一维自然是$i+1$
$j$这一维，有了之前的预处理，直接可以知道转移到哪里
$k$这一维，填左括号+1 ，右括号-1（注意$k==0$时不可以填右括号）
$l$这一维，如果$j$的那一维转移到了$|s|$的位置可以或上一个1
就转移完了。

我是没想出来啊没想出来。一开始想枚举出现的位置，然后左右算一下方案。后来发现这样的话，如果一个序列中包含多个$s$就会凉.然后就想去计算重复的，于是想出了一个$dp[i][j][k]$表示当前长度为$i$，在$s$的第$j$位，已经包含了$k$个 s s <script type="math/tex" id="MathJax-Element-2087">s</script>的方案数。后来发现不合法的序列也会被算进去，然后就搞不来了。惨啊。看了状态表示秒懂。

代码有滚动数组优化，不优化也能过。

//QWsin
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define rep(i,x,y) for(int i=x;i<=y;++i)
#define out(i,u) for(int i=first[u];i!=-1;i=next[i])
using namespace std;

const int MOD=1e9+7;
const int INF=1<<30;
const int maxn=200+10;

typedef long long ll;

ll dp[2][maxn][maxn][2];

char s[maxn],t[maxn];

int n;

int f[maxn],to[maxn][2],tmp[maxn];

int main()
{
    cin>>n;n*=2;


    scanf("%s",s+1);
    int l=strlen(s+1);

    int top=0;
    rep(i,1,l)
    {
        if(s[i]==')' && t[top]=='(') t[top--]=0;
        else t[++top]=s[i]; 
    }

    int a=0,b=0;
    rep(i,1,top) if(t[i]==')') ++a;else ++b;

    int k=0;f[1]=0;
    for(int i=2;i<=l;i++)
    {
        while(k&&s[k+1]!=s[i]) k=f[k];
        if(s[k+1]==s[i]) k++;
        f[i]=k;
    }

    rep(i,1,l) tmp[i]= (s[i]=='('?0:1);
    tmp[l+1]=2;

    rep(i,0,l)
    {
        rep(j,0,1)
        {
            int t=i;
            while(t && tmp[t+1]!=j) t=f[t];
            if(tmp[t+1]==j) to[i][j]=t+1;   
        }
    }

    dp[0][0][0][0]=1;
    int cur=1;
    rep(i,0,n-1) 
    {
        rep(j,0,l) rep(k,0,i+1) rep(o,0,1) dp[cur][j][k][o]=0;
        rep(j,0,l) rep(k,0,i) rep(o,0,1) if(dp[cur^1][j][k][o])
        {
            rep(p,0,1) {
                if(p==1 && k==0) continue;
                (dp[cur][to[j][p]][k+(p?-1:1)][o|(to[j][p]==l)]+=dp[cur^1][j][k][o])%=MOD;
            }
        }
        cur^=1;
    }

    ll ans=0;
    rep(j,0,l) (ans+=dp[cur^1][j][0][1])%=MOD;

    cout<<ans<<endl;
    return 0;
}