第九周 10.25-10.31

10.25

HDU 4117 GRE Words

卡了很久的一个题目。比较综合。

看了很久题解还是各种写挫。

毕竟除了模拟题都没敲过那么长的。

题意：按顺序给N个单词，每个单词有权值，删去其中任意单词，使得前面的单词为后面单词的子串，求最大权值和。

做法：先建好AC自动机。

　　　最先想到的方法应该是这样的。

　　　定义dp[i]为以第i个串为最后一个串的答案。

　　　转移是dp[i]=max{W[i],dp[j]+W[i]}(j为i子串)

　　　那么只要再拿这N个单词在AC自动机上匹配一遍。

　　　每过一个节点相当于经过这个串的一个前缀。而这个节点的fail指向的是这个前缀的后缀。

　　　于是经过的每个节点时都通过fail一直走到root就遍历了这个串的所有子串。

　　　那么我们不妨定义f[u]为节点u所对应的单词的所有后缀的答案。

　　　那么可以用这种方法借助f[]来求出dp。

　　　

　　　然而这样是T的。

　　　于是考虑一种用线段树优化的方法。

　　　

　　　考虑到我们每次是顺着fail指针更新答案的。而且每次更新一个节点后只会影响fail指向它的节点。

　　　按照fail反向建树。这样每个父节点都是孩子节点的前缀。也就是每次更新一个节点后只影响它的子树。

　　　先在fail树上dfs一遍打好时间戳。

　　　线段树的每个节点维护时间戳所对应的fail树上节点的f[]值。

　　　于是按照段更新的区间最值线段树写就可以了。

　　　每次询问所有前缀的f[]。再更新末节点对应子树的f[]。

　　　所有取最大即为答案。

　　　

　　　最后防爆栈黑科技交C++。　　　

#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int maxnode=3e5+10,sigma_size=26;
const int maxn=2e4+10;
int n,p[maxn],W[maxn];
char s[maxnode];

//fail_tree
int cnt,headlist[maxnode];
int timer,dfn[maxnode][2];
struct e
{
    int to,pre;
} edge[2*maxnode];

void add(int from,int to)
{
    cnt++;
    edge[cnt].pre=headlist[from];
    edge[cnt].to=to;
    headlist[from]=cnt;
}

void dfs(int pos,int fa)
{
    dfn[pos][0]=++timer;
    for(int i=headlist[pos];i;i=edge[i].pre)
    {
        int to=edge[i].to;
        if(to==fa) continue;
        dfs(to,pos);
    }
    dfn[pos][1]=++timer;
}

//seg_tree
struct seg_tree
{
    int l,r,val;
}tree[maxnode<<3];

void buildtree(int pos,int l,int r)
{
    tree[pos].l=l;
    tree[pos].r=r;
    tree[pos].val=0;
    if(l<r)
    {
        buildtree(pos*2,l,(l+r)/2);
        buildtree(pos*2+1,(l+r)/2+1,r);
    }
}

void pushdown(int pos)
{
    tree[2*pos].val=max(tree[2*pos].val,tree[pos].val);
    tree[2*pos+1].val=max(tree[2*pos+1].val,tree[pos].val);
}

void update(int pos,int l,int r,int val)
{
    if(tree[pos].l>=l&&tree[pos].r<=r) tree[pos].val=max(tree[pos].val,val);
    else
    {
        pushdown(pos);
        if((tree[pos].l+tree[pos].r)/2>=r) update(pos*2,l,r,val);
        else if((tree[pos].l+tree[pos].r)/2<l) update(pos*2+1,l,r,val);
        else
        {
            update(pos*2,l,r,val);
            update(pos*2+1,l,r,val);
        }
    }
}

int query(int pos,int l,int r)
{
    if(tree[pos].l>=l&&tree[pos].r<=r) return tree[pos].val;
    int ret=0;
    pushdown(pos);
    if((tree[pos].l+tree[pos].r)/2>=r) ret=max(ret,query(pos*2,l,r));
    else if((tree[pos].l+tree[pos].r)/2<l) ret=max(ret,query(pos*2+1,l,r));
    else
    {
        ret=max(ret,query(pos*2,l,r));
        ret=max(ret,query(pos*2+1,l,r));
    }
    return ret;
}

struct Ac_auto
{
    int Next[maxnode][sigma_size];
    int fail[maxnode];
    int sz;
    Ac_auto(){sz=1;memset(Next[0],0,sizeof(Next[0]));}
    void init(){sz=1;memset(Next[0],0,sizeof(Next[0]));}
    int idx(char c) {return c-'a';}

    void insert(char *s)
    {
        int u=0,n=strlen(s);
        for(int i=0;i<n;i++)
        {
            int c=idx(s[i]);
            if(!Next[u][c])
            {
                memset(Next[sz],0,sizeof(Next[sz]));
                Next[u][c]=sz++;
            }
            u=Next[u][c];
        }
    }

    void build()
    {
        queue<int> q;
        fail[0]=0;
        for(int i=0;i<sigma_size;i++) if(Next[0][i])
        {
            fail[Next[0][i]]=0;
            q.push(Next[0][i]);
        }
        while(!q.empty())
        {
            int pos=q.front(); q.pop();
            for(int i=0;i<sigma_size;i++)
            {
                if(!Next[pos][i]) Next[pos][i]=Next[fail[pos]][i];
                else
                {
                    fail[Next[pos][i]]=Next[fail[pos]][i];
                    q.push(Next[pos][i]);
                }
            }
        }
    }

    void fail_tree()
    {
        cnt=0;
        memset(headlist,0,sizeof(headlist));
        for(int i=1;i<sz;i++)
        {
            add(i,fail[i]);
            add(fail[i],i);
        }
    }

    int solve()
    {
        int ret=0;
        for(int i=1;i<=n;i++)
        {
            int u=0,tmp=0;
            for(int j=p[i-1];j<p[i];j++)
            {
                u=Next[u][idx(s[j])];
                tmp=max(tmp,query(1,dfn[u][0],dfn[u][0])+W[i]);
            }
            ret=max(ret,tmp);
            update(1,dfn[u][0],dfn[u][1],tmp);
        }
        return ret;
    }

}ACA;


int main(void)
{
    int T; scanf("%d",&T);
    for(int kase=1;kase<=T;kase++)
    {
        scanf("%d",&n);
        ACA.init();
        for(int i=1;i<=n;i++)
        {
            scanf("%s%d",s+p[i-1],W+i);
            ACA.insert(s+p[i-1]);
            p[i]=p[i-1]+strlen(s+p[i-1]);
        }
        ACA.build();
        ACA.fail_tree();
        timer=0;
        dfs(0,-1);
        buildtree(1,1,timer);
        printf("Case #%d: %d
",kase,ACA.solve());
    }
    return 0;
}

10.26-10.31

什么都没干。