[校内训练20_05_27]BC

2.给一个点数<=15的联通无向图的边定向，要求定向后存在一种方案使得1号点和2号点能到达同一个点。问合法方案数。

考虑容斥，每次选出两个分别包含1、2的联通块并让它们不相交，且没有横跨两个联通跨的边，那么答案就要减去$2^k*f[S]*g[S]$，其中k是两个点都不在联通块的边的数量，f表示包含点1且从1出发能够到达S中任意一个点的方案数，g同理。

由于f是恰好到达，因此仍然是容斥即可。具体见代码。复杂度O(3^n)。

#define mod 1000000007
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
int n,m;
ll pow2[555],f[(1<<15)+1],g[(1<<15)+1];
int a[555][2],b[(1<<15)+1];
bool can[(1<<15)+1];
inline void init()
{
    pow2[0]=1;
    for(int i=1;i<=500;++i)
        pow2[i]=pow2[i-1]*2%mod;
    can[0]=1;
    for(int i=0;i<n;++i)
        can[1<<i]=1;
    for(int k=1;k<=n;++k)
    for(int i=1;i<=m;++i)
    {
        int x=a[i][0],y=a[i][1];
        for(int S=0;S<(1<<n);++S)
        {
            if(S&(1<<x))
                can[S|(1<<y)]|=can[S];
            if(S&(1<<y))
                can[S|(1<<x)]|=can[S];
        }
    }
}
bool vis[(1<<15)+1];
inline int in(int S)
{
    if(vis[S])
        return b[S];
    vis[S]=1;
    int s=0;
    for(int i=1;i<=m;++i)
        if((S&(1<<a[i][0]))&&(S&(1<<a[i][1])))
            ++s;
    return b[S]=s;
}
inline void solveF()
{
    f[0]=1;
    for(int S=1;S<(1<<n);++S)
    {
        if(!(S&1))
            continue;
        if(!can[S])
            continue;
        f[S]=pow2[in(S)];
        for(int s=(S-1)&S;s;s=(s-1)&S)
        {
            if(!(s&1))
                continue;
            if(!can[s])
                continue;
            f[S]=(f[S]-pow2[in(S^s)]*f[s]%mod+mod)%mod;
        }
    }
}
inline void solveG()
{
    g[0]=1;
    for(int S=1;S<(1<<n);++S)
    {
        if(!(S&2))
            continue;
        if(!can[S])
            continue;
        g[S]=pow2[in(S)];
        for(int s=(S-1)&S;s;s=(s-1)&S)
        {
            if(!(s&2))
                continue;
            if(!can[s])
                continue;
            g[S]=(g[S]-pow2[in(S^s)]*g[s]%mod+mod)%mod;
        }
    }
}
inline bool cross(int S1,int S2)
{
    for(int i=1;i<=m;++i)
    {
        int x=a[i][0],y=a[i][1];
        if((S1&(1<<x))&&(S2&(1<<y)))
            return true;
        if((S1&(1<<y))&&(S2&(1<<x)))
            return true;
    }
    return false;
}
inline void solve()
{
    ll ans=pow2[m];
    for(int S1=0;S1<(1<<n);++S1)
    {
        if(!(S1&1))
            continue;
        int S=((1<<n)-1)^S1;
        for(int S2=S;S2;S2=(S2-1)&S)
        {
            if(!(S2&2))
                continue;
            if(cross(S1,S2))
                continue;
            if(!(can[S1]&&can[S2]))
                continue;
            ans=(ans-f[S1]*g[S2]%mod*pow2[in(S^S2)]%mod+mod)%mod;
        }
    }
    cout<<ans<<endl;
}
int main()
{
    ios::sync_with_stdio(false);
    int useless;
    cin>>n>>m>>useless;
    for(int i=1;i<=m;++i)
    {
        cin>>a[i][0]>>a[i][1];
        --a[i][0],--a[i][1];
    }
    init();
    solveF();
    solveG();
    solve();
    return 0;
}

---

3.一个字符串，从中划分出一些不相交的子串，要求第i+1个串是第i个串的严格子串。问做多划分多少个。

显然串的长度是[1,k]，k是总个数。将这个字符串翻转过来，则要求第i个串是前一个串的子串且长度恰好+1。令fi以第i位结尾的最长划分个数，每次往后更新，相当于在SAM上定位到这个节点并且进行子树取max操作。由于要求不相交，相当于有一个时间的限制，用堆维护即可。

注意更新时要在parent tree上调到祖先节点去更新，如果访问过就break。

#include<bits/stdc++.h>
using namespace std;
const int maxn=1E6+5;
int n;
namespace SAM
{
    int tot=1,last=1;
    int back[maxn*2];
    struct node
    {
        int fa,len,ch[26];
    }t[maxn*2];
    inline void insert(int x,int id)
    {
        int now=++tot,u=last;
        last=tot;
        back[id]=now;
        t[now].len=t[u].len+1;
        for(;u&&!t[u].ch[x];u=t[u].fa)
            t[u].ch[x]=now;
        if(!u)
            t[now].fa=1;
        else
        {
            int v=t[u].ch[x];
            if(t[v].len==t[u].len+1)
                t[now].fa=v;
            else
            {
                int w=++tot;
                t[w]=t[v];
                t[w].len=t[u].len+1;
                t[v].fa=t[now].fa=w;
                for(;u&&t[u].ch[x]==v;u=t[u].fa)
                    t[u].ch[x]=w;
            }
        }
    }
}
namespace TREE
{
    int size,head[maxn*2];
    int dep[maxn*2],fa[maxn*2][20];
    int TI,dfn[maxn*2],low[maxn*2],where[maxn*2];
    struct edge
    {
        int to,next;
    }E[maxn*2];
    struct pt
    {
        int time,u,v;
        pt(int a=0,int b=0,int c=0):time(a),u(b),v(c){}
        bool operator<(const pt&A)const
        {
            return time>A.time;
        }
    };
    inline void add(int u,int v)
    {
        E[++size].to=v;
        E[size].next=head[u];
        head[u]=size;
    }
    inline void build()
    {
        for(int i=2;i<=SAM::tot;++i)
            add(SAM::t[i].fa,i);
    }
    void dfs(int u,int d)
    {
        dep[u]=d;
        fa[u][0]=SAM::t[u].fa;
        for(int i=1;i<20;++i)
            fa[u][i]=fa[fa[u][i-1]][i-1];
        dfn[u]=low[u]=++TI;
        where[TI]=u;
        for(int i=head[u];i;i=E[i].next)
        {
            int v=E[i].to;
            dfs(v,d+1);
            low[u]=low[v];
        }
    }
    inline int jump(int x,int d)
    {
        for(int i=19;i>=0;--i)
            if(SAM::t[fa[x][i]].len>=d)
                x=fa[x][i];
        return x;
    }
    int t[maxn*8];
    int f[maxn];
    void change(int L,int R,int l,int r,int x,int num)
    {
        if(L<=l&&r<=R)
        {
            t[num]=max(t[num],x);
            return;
        }
        int mid=(l+r)>>1;
        t[num<<1]=max(t[num<<1],t[num]);
        t[num<<1|1]=max(t[num<<1|1],t[num]);
        if(R<=mid)
            change(L,R,l,mid,x,num<<1);
        else if(mid<L)
            change(L,R,mid+1,r,x,num<<1|1);
        else
            change(L,R,l,mid,x,num<<1),change(L,R,mid+1,r,x,num<<1|1);
    }
    inline int ask(int l,int r,int pos,int num)
    {
        if(l==r)
            return t[num];
        int mid=(l+r)>>1;
        t[num<<1]=max(t[num<<1],t[num]);
        t[num<<1|1]=max(t[num<<1|1],t[num]);
        if(pos<=mid)
            return ask(l,mid,pos,num<<1);
        else
            return ask(mid+1,r,pos,num<<1|1);
    }
    bool vis[maxn*2];
    void solve()
    {
        change(1,TI,1,TI,1,1);
        dfs(1,0); 
        for(int i=1;i<=n;++i)
            f[i]=1;
        priority_queue<pt>Q;
        int ans=0;
        for(int i=1;i<=n;++i)
        {
            while(!Q.empty())
            {
                pt A=Q.top();
                if(i<A.time)
                    break;
                Q.pop();
                change(dfn[A.u],low[A.u],1,TI,A.v,1);
            }
            int u=SAM::back[i];
            f[i]=ask(1,TI,dfn[u],1);
//            cout<<i<<" "<<f[i]<<endl;

            u=jump(u,f[i]);
            int len=f[i];
            do
            {
                if(len)
                    Q.push(pt(len+i+1,u,len+1));
                vis[u]=1;
                u=SAM::t[u].fa;
                len=SAM::t[u].len;
            }while(!vis[u]);
            
            u=jump(SAM::back[i],f[i]);
            for(int j=0;j<26;++j)
            {
                if(SAM::t[u].ch[j])
                    Q.push(pt(f[i]+i+1,SAM::t[u].ch[j],f[i]+1));/*
                if(SAM::t[u].ch[j])
                {
                    int v=SAM::t[u].ch[j];
                    len=f[i];
                    do
                    {
                        if(len)
                            Q.push(pt(len+i+1,v,len+1));
                        vis[v]=1;
                        v=SAM::t[v].fa;
                        len=SAM::t[v].len;
                    }while(!vis[v]);
                }*/
            }
            ans=max(ans,f[i]);
        }
        cout<<ans<<endl;
    }
}
string str;
int main()
{
//    freopen("brr.in","r",stdin);
//    freopen("brr.out","w",stdout);
    ios::sync_with_stdio(false);
    cin>>str;
    n=str.size();
    reverse(str.begin(),str.end());
//    cout<<str<<endl;
    str="!"+str;
    for(int i=1;i<=n;++i)
        SAM::insert(str[i]-'a',i);
    TREE::build();
    TREE::solve();
    return 0;
}
//abcdbcdbcc