【HDU3247】 Resource Archiver(DP+AC自动机+最短路)

Resource Archiver

Time Limit: 10000MS

Memory Limit: 100000KB

64bit IO Format: %I64d & %I64u

Description

Great! Your new software is almost finished! The only thing left to do is archiving all your n resource files into a big one. 
Wait a minute… you realized that it isn’t as easy as you thought. Think about the virus killers. They’ll find your software suspicious, if your software contains one of the m predefined virus codes. You absolutely don’t want this to happen. 
Technically, resource files and virus codes are merely 01 strings. You’ve already convinced yourself that none of the resource strings contain a virus code, but if you make the archive arbitrarily, virus codes can still be found somewhere. 
Here comes your task (formally): design a 01 string that contains all your resources (their occurrences can overlap), but none of the virus codes. To make your software smaller in size, the string should be as short as possible.

 

Input

There will be at most 10 test cases, each begins with two integers in a single line: n and m (2 <= n <= 10, 1 <= m <= 1000). The next n lines contain the resources, one in each line. The next m lines contain the virus codes, one in each line. The resources and virus codes are all non-empty 01 strings without spaces inside. Each resource is at most 1000 characters long. The total length of all virus codes is at most 50000. The input ends with n = m = 0.

 

Output

For each test case, print the length of shortest string.

 

Sample Input

2 2

1110

0111

101

1001

0 0

 

Sample Output

5

 

【题意】

　　给出n个资源，m个病毒，将资源串拼接成一个串，必须包含所有的资源串，可以重叠，但是不能包含病毒。问最小的长度为多少。

【分析】

　　良心题解：http://blog.csdn.net/woshi250hua/article/details/8021283

               

　　· 一开始要想到DP，这是最简单的一步。而且n很小明显是状压，再用一维记录一下最后一个拼接的串。

       即d[i][j]表示现在已经拼接的串集合为i，最后一个串为j的最小费用。

　　转移方程->d[i+(1<<k-1)][k]=min{d[i+(1<<k-1)][k],d[i][j]+cost[j][k]}

　　转移方程是很容易想的，重点就是求cost[j][k]。

　　暴力的话，目测是10*10*1000*1000，有点慢- -。

　　所以，要用到优美的性质才行。

　　把两种串都建在AC自动机里，打上不同标记，然后按上面所说的沿着next向下走。

　　理解了很久这个沿着next向下走的过程之后，我觉得意思应该是这样：

　　

　　a串和b串连接有很多种方式，其实可以转换成 -> 自己生成一个串，使得前缀是a串，后缀是b串。（如上图第一种情况）

　　之前做生成串的题目都是在图上沿nest走的，这样只要不走到危险节点，就不会出现病毒串（fail的优美性质）。

　　所以，我们就可以利用这种方法求出拼接且不含危险串的串了。

　　要让这个拼接串长度最小，也就是走的从a的末尾节点走到b的末尾节点的路程最小。（因为答案为a串长度+走的步数，而a串长度一定）

　　就是一个最短路。

　　

　　其实感觉有一个小小的BUG，就是无论a，b串怎么拼都含病毒串，他会输出一个大于l[a]+l[b]的数，相当于在a、b串中乱填东西，使得不含病毒串（如上图第二种情况）。这样就与“拼接”的含义不符了。

　　你可以简单的判断一下之类的，但是我没有判断也A了。可能是正确的最优解覆盖了它的原因。

　　AC自动机要建60000不是50000。（一开始RE了~~）

代码如下：

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
#define Maxn 60010
#define Maxl 1200
#define Mn 20
#define INF 0xfffffff
#define Mod 20090717

int n,m;
char s[Maxl];

struct node
{
    // int cnt;
    int fail,mark;
    int son[3];
}t[Maxn];int tot;
// int num;
int p[Mn],sl[Mn];

void upd(int x)
{
    // t[x].cnt=0;
    t[x].mark=0;
    memset(t[x].son,0,sizeof(t[x].son));
}

int mymin(int x,int y) {return x<y?x:y;}
int mymax(int x,int y) {return x>y?x:y;}

void read_trie(int tk)
{
    scanf("%s",s+1);
    int len=strlen(s+1);
    if(tk!=-1) sl[tk]=len;
    int now=0;
    for(int i=1;i<=len;i++)
    {
        int ind=s[i]-'0'+1;
        if(!t[now].son[ind]) 
        {
            t[now].son[ind]=++tot;
            upd(tot);
        }
        now=t[now].son[ind];
        if(i==len) 
        {
            if(tk==-1) t[now].mark=-1;
            else t[now].mark=tk,p[tk]=now;
        }
    }
}

queue<int > q;
void build_AC()
{
    while(!q.empty()) q.pop();
    q.push(0);
    while(!q.empty())
    {
        int x=q.front();q.pop();
        for(int i=1;i<=2;i++) 
        {
            if(t[x].son[i])
            {
                t[t[x].son[i]].fail=x?t[t[x].fail].son[i]:0;
                q.push(t[x].son[i]);
            }
            else t[x].son[i]=t[t[x].fail].son[i];
        }
        // t[x].mark+=t[t[x].fail].mark;
    }
}

int dis[Mn][Maxn];
bool inq[Mn];
void spfa(int x)
{
    while(!q.empty()) q.pop();
    memset(dis[x],63,sizeof(dis[x]));
    memset(inq,0,sizeof(inq));
    dis[x][p[x]]=0;
    q.push(p[x]);inq[p[x]]=1;
    while(!q.empty())
    {
        int now=q.front();
        for(int i=1;i<=2;i++) if(t[t[now].son[i]].mark!=-1)
        {
            if(dis[x][t[now].son[i]]>dis[x][now]+1)
            {
                dis[x][t[now].son[i]]=dis[x][now]+1;
                if(!inq[t[now].son[i]])
                {
                    inq[t[now].son[i]]=1;
                    q.push(t[now].son[i]);
                }
            }
        }
        q.pop();inq[now]=0;
    }
}
void init()
{
    tot=0;upd(0);
    for(int i=1;i<=n;i++)
    {
        read_trie(i);
    }
    for(int i=1;i<=m;i++) read_trie(-1);
    build_AC();
    for(int i=1;i<=n;i++)
    {
        spfa(i);
    }
}

bool check(int x,int y,int z)
{
    // if(x==0&&y==0&&z==0) return 1;
    // if(y==0||z==0) return 0;
    if(((1<<y-1)&z)==0) return 0;
    int h=0;
    for(int i=1;i<=n;i++)
    {
        if((1<<i-1)&z) h++;
    }
    if(h==x) return 1;
    return 0;
}

int f[Maxl][Mn];
void dp()
{
    memset(f,63,sizeof(f));
    // f[0][0]=0;
    for(int i=1;i<=n;i++) f[1<<i-1][i]=sl[i];
    for(int i=1;i<n;i++)
     for(int j=1;j<=n;j++)
      for(int k=1;k<=(1<<n)-1;k++) if(check(i,j,k))
      {
          if(f[k][j]>INF) continue;
          for(int l=1;l<=n;l++) if((k&(1<<l-1))==0)
          f[k+(1<<l-1)][l]=mymin(f[k+(1<<l-1)][l],f[k][j]+dis[j][p[l]]);
      }
    int ans=INF;
    for(int i=1;i<=n;i++) ans=mymin(ans,f[(1<<n)-1][i]);
    printf("%d
",ans);
}

int main()
{
    int kase=0;
    while(1)
    {
        scanf("%d%d",&n,&m);
        if(n==0&&m==0) break;
        init();
        dp();
    }
    return 0;
}

2016-07-13 09:55:14