Codeforces

Codeforces 7E

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <map>
using namespace std;
map<string,int> Map;
int KASE;
string Str,t;
char Tmp[110];
inline int Get(int l,int r)
{
    int L,R,B=0;
    for (int i=r-1;i>=l;i--)
    {
        B+=(t[i]=='(')-(t[i]==')');
        if (!B && (t[i]=='+' || t[i]=='-'))
        {
            L=Get(l,i),R=Get(i+1,r);
            return L && R && (t[i]=='+' || R>1);
        }
    }
    for (int i=r-1;i>=l;i--)
    {
        B+=(t[i]=='(')-(t[i]==')');
        if (!B && (t[i]=='*' || t[i]=='/'))
        {
            L=Get(l,i),R=Get(i+1,r);
            return L>1 && R>1 && (t[i]=='*' || R==3)?2:0;
        }
    }
    if (t[l]=='(') return Get(l+1,r-1)?3:0;
    string x=t.substr(l,r-l);
    return Map.count(x)?Map[x]:3;
}
inline int Work()
{
    gets(Tmp);
    int Len=strlen(Tmp); t="";
    for (int i=0;i<Len;i++) if (Tmp[i]!=' ') t+=Tmp[i];
    return Get(0,t.size());
}
int main()
{
    scanf("%d",&KASE);
    for (int Kase=1;Kase<=KASE;Kase++)
    {
        scanf(" #%*s"),cin>> Str;
        Map[Str]=Work();
    }
    puts(Work()?"OK":"Suspicious");
    return 0;
}

我们考虑一个宏是否是“安全”的，经过观察和一些实验，可以发现，只有以下4种状态：

• 状态1(s1)： 这个宏完全安全，以任何方式使用该宏都没问题。

• 状态2(s2)： 这个宏不安全，只要表达式中出现该宏，都会导致表达式不安全。

• 状态3(s3)： 这个宏部分安全，仅当这个宏与’*’,’/’连接时，或出现在’-’后面时，才会使 表达式不安全。

• 状态4(s4)： 这个宏部分安全，仅当这个宏出现在’/’后面时，才会使表达式不安全。

有了这4个状态，我们只需推出状态之间的转移即可。

• 如果表达式没有使用任何运算符或括号或宏（也就是s仅仅是个单独的变量），那么安 全级别显然是s1

• 如果表达式s是(t)的形式（被一对括号括起来的表达式t），那么如果t的状态不是s2， 则s的状态是s1，否则s的状态是s2

• 我们找到表达式s中，最后一次运算的符号，设其为op，设其两侧表达式分别为t1和t2。 我们进行以下分类讨论：

– 显然，如果t1或t2的安全状态是s2，则s的状态也是s2;

– 如果op是’+’，那么s的状态是s3; – 如果op是’-’，那么，如t2状态是s3，则s状态是s2，否则s状态是s3

– 如果op是’*’，那么，如t1或t2状态是s3，则s状态是s2，否则s状态是s4

– 如果op是’/’，那么，如t1或t2状态是s3，或t2状态是s4，则s状态是s2，否则s状态是s4

于是，此题得到了解决。 时间复杂度O(n∗len2)，如果愿意追求更好的复杂度，可以建 出表达式树，从而做到O(N ∗len)

Codeforces 17C

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
int F[154][54][54][54],Pos[200];
int Next[160][4],n,Ans=0;
char Str[200];
const int Mod=51123987;
inline int Abs(int x) {return x>0?x:-x;}
int main()
{
    scanf("%d",&n); int m=n/3+1;
    scanf("%s",Str+1); 
    for (int i=n;i>=1;i--)
    {
        Pos[Str[i]]=i;
        for (int j=1;j<=3;j++) Next[i][j]=Pos[j+'a'-1];
     }
    F[1][0][0][0]=1;
    for (int i=1;i<=n;i++)
    {
        for (int a=0;a<=m;a++)
            for (int b=0;b<=m;b++)
                for (int c=0;c<=m;c++)
                {
                    if (!F[i][a][b][c]) continue;
                    if (a+b+c==n && Abs(a-b)<=1 && Abs(a-c)<=1 && Abs(b-c)<=1) Ans=(Ans+F[i][a][b][c])%Mod;
                    F[Next[i][1]][a+1][b][c]=(F[Next[i][1]][a+1][b][c]+F[i][a][b][c])%Mod;
                    F[Next[i][2]][a][b+1][c]=(F[Next[i][2]][a][b+1][c]+F[i][a][b][c])%Mod;
                    F[Next[i][3]][a][b][c+1]=(F[Next[i][3]][a][b][c+1]+F[i][a][b][c])%Mod;
                }
    }
    printf("%d
",Ans);
    return 0;
}

一段连续的字母必定对应原 串的某个字符， 原串的某个字符也必定对应可以得到的串中一段连续的字母。Dp就可以了。

Codeforces 17E

#include <cstdio>
#define LL long long
using namespace std;
const LL Maxn=4000010;
const LL Mod=51123987;
char Str[Maxn],S[Maxn];
LL P[Maxn],n,a[Maxn],b[Maxn],Ans=0;
inline LL Min(LL x,LL y) {return x>y?y:x;}
inline void Manacher()
{
    Str[0]='$'; Str[1]='#'; Str[(n<<1)+2]='^';
    for (LL i=1;i<=n;i++) Str[i<<1]=S[i],Str[i<<1|1]='#';  
    LL Mx=0,Id=0; n=n<<1|1;
    for (LL i=1;i<=n;i++)
    {
        if (i<Mx) P[i]=Min(Mx-i,P[2*Id-i]); else P[i]=1;
        while (Str[i-P[i]]==Str[i+P[i]]) P[i]++;
        if (P[i]+i>Mx)     Mx=P[i]+i,Id=i;
    }
}
int main()
{
    scanf("%I64d",&n); LL nn=n;
    scanf("%s",S+1);
    Manacher();
    for (LL i=1;i<=n+1;i++) a[(i-P[i])/2+1]++,a[i/2+1]--,b[(i+1)/2]++,b[(i+P[i])/2]--,Ans+=P[i]/2;
    for (LL i=1;i<=n;i++) a[i]+=a[i-1],b[i]+=b[i-1];
    Ans%=Mod; Ans=(Ans*(Ans-1))/2%Mod;
    for (LL i=1;i<=nn;i++) (b[i]+=b[i-1])%Mod,Ans=(Ans-a[i]*b[i-1])%Mod;
    printf("%I64d
",(Ans+Mod)%Mod);
    return 0;
}

可以用Manacher算出每个字符为中心的回文串的最大长度。相交的对数=总的对数-不相交的对数， 那窝萌统计不想交的对数。

sum[i]表示右边界小于等于i的回文串个数，cnt[i]表示左边界等于i的回文串个数。那么就是∑sum[i]*cnt[i+1]

那么如何统计cnt[i]呢，求出Manacher求出P[i]以后，从左边界加一右边界减一从左往右加即可.

sum[i]就是再次从往右加即可.

Codeforce 23E

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int Maxn=710;
struct EDGE{int to,next;}edge[Maxn<<2];
int head[Maxn],n,u,v,F[Maxn][Maxn],cnt,Size[Maxn];
inline int Max(int x,int y) {return x>y?x:y;}
inline void Add(int u,int v)
{edge[cnt].to=v;edge[cnt].next=head[u];head[u]=cnt++;}
void Dfs(int u,int fa)
{
    Size[u]=1;
    for (int i=1;i<=n;i++) F[u][i]=1;
    for (int i=head[u];i!=-1;i=edge[i].next)
    {
        if (edge[i].to==fa) continue;
        Dfs(edge[i].to,u);
        for (int j=Size[u];j;j--)
        {
            for (int k=1;k<=Size[edge[i].to];k++)
            {
                int x=F[u][j]*F[edge[i].to][k];
                F[u][j+k]=Max(F[u][j+k],x);
            }
            F[u][j]=F[u][j]*F[edge[i].to][0];
        }
        Size[u]+=Size[edge[i].to];
    }
    for (int i=1;i<=Size[u];i++)
    {
        int x=F[u][i]*i;
        F[u][0]=Max(F[u][0],x);
    }
}
int main()
{
    scanf("%d",&n);
    memset(head,-1,sizeof(head));
    for (int i=1;i<n;i++)
    {
        scanf("%d%d",&u,&v);
        Add(u,v),Add(v,u);
    }
    Dfs(1,0);
    printf("%d
",F[1][0]);
    return 0;
}

需要高精度.

用F[i][s]表示考虑以i为根的子树，且i所属的连通块大小是s时的最大值

转移：对于i的每个孩子j，枚举k，用dp[j][k]∗dp[i][s]去更新dp[i][s+k]即可.