HDU 3247 Resource Archiver（AC自动机+BFS+状压DP）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3247

参考博客：https://www.cnblogs.com/kuangbin/p/3164106.html

---

不能处理的数据：

2 1
11 00
1100

也不知道这种病毒串是否合法，我觉得应该不会出现这种病毒串，不然压缩原本字符串的过程中间还得添几个其他的字符也算不上是压缩了。

各处盗来的测试数据：(有几组数据有重复串，插入串的时候处理一下，那几组不对也能A，想要对的话插入的时候稍微改一下就行，见代码）

Input：

3 1
00000
00000
11111
01

3 2
101
010
1111
001
011

2 2
1110
0111
101
1001

3 3
0001
0000
10000
010
101
111

3 3
00000
00000
00000
101
101
101

2 2
01
10
010
101

3 3
0001
0000
10000
010
101
111

0 0

Output：

10
7
5
6
5
4
6

---

 

解题思路：

精简的说法：

利用AC自动机的特性，BFS单词节点求出各个单词末到另一个单词末节点需要的最短路径，建立一个图，问题变成：从起点出发，至少走过所有单词一遍所需的最短路径，这个问题就是旅行商问题（TSP），在点数较少时可以用状压DP做

---

详细说明：

构造：

先把需要压缩的串（下面简称原串），以及病毒串插入字典树，用val[]记录单词末节点信息，病毒标记为-1，每个不同的原串结尾标记为不同的状态。

构造AC自动机的时候每个节点记录更新当前节点后缀连接上所有单词，然后后缀上出现病毒的把当前节点直接记做病毒节点。

BFS：

我们记录每个val[]>0，即当前节点是单词末，或者后缀是单词的节点，这些点全都要BFS（此做法灵魂），并且都作为DP过程的节点，而不仅仅BFS每个单词末节点，因为BFS对于其中一些原串是另一些原串的子串求得的距离是有问题的

比如10001 和 000，串1到串2的距离为0，然而BFS求出来所有距离至少是1。

同时BFS每个节点只更新一次：因为之前更新过的距离一定比现在短。

整个BFS的过程可以理解为：首先我们已经到了这个单词的末节点，然后我们枚举下一位的所有情况，根据AC自动机跳到对应的节点即是包含当前枚举的这一位，后缀相同最多的其他根节点开始的链的前缀，也就是说我们当前枚举一位就可以利用之前的后缀匹配到那个位置（BB了半天就是AC自动机走trie图的意义），走trie图可以规避目前形成了病毒的情况，如果形成了病毒就不跳那个点了，然后走trie图也是最大利用了当前的后缀，这样找到的单词末节点就是最短的。

但是很明显，最大利用了当前的后缀的话很可能已经跳过了一些单词节点，因此需要BFS所有后缀包含单词的节点，“当前求错的用多求来弥补”。

画个粗糙的图帮助理解一下：

状压DP：

DP的话问题不大了。

BFS构造出mp[][]表示单词节点相连的最短路径，mp[0][]就是根节点到每个单词的长度

mp[i][j] = -1的点即BFS中无法更新到的点

（不理解为什么BFS会有不能到的点的话，可以手动模拟一下 2 1 11 00 10这组数据求mp[1][]的过程）

dp[][]数组只初始化dp[0][0]=0，保证最后走遍所有点的最优解一定是从根节点出发。

DP看不懂可以先做HDU 5418（题面差不多就是这题处理好后的状态）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5418

HDU5418的题解：https://blog.csdn.net/weixin_43768644/article/details/99689585

---

 

代码：（基本就是参考博客抄作业啦）

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<set>
#include<map>
#include<algorithm>

using namespace std;

#define ll long long
#define ull unsigned long long
#define for1(i,a,b) for (int i=a;i<=b;i++)
#define for0(i,a,b) for (int i=a;i<b;i++)
#define rof1(i,a,b) for (int i=a;i>=b;i--)
#define rof0(i,a,b) for (int i=a;i>b;i--)
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define debug(x) printf("----Line %s----\n",#x)
#define pt(x,y) printf("%s = %d\n",#x,y)
#define INF 0x3f3f3f3f
#define dfl(x) ll x;scanf("%I64d",&x)
#define df2l(x,y) ll x,y;scanf("%I64d %I64d",&x,&y)
#define df(x) int x;scanf("%d",&x);
#define df2(x,y) int x,y;scanf("%d %d",&x,&y)
#define mod 1000000007
#define duozu(T) int T;scanf("%d",&T);while (T--)

const int N = 5e4+5;

const int maxnode = 10*1000+50000+5;//模式串数量*长度
const int ALP = 2;//字符种类数

char s[N];

struct AC_am
{
    queue<int>que;
    int sz;
    int trie[maxnode][ALP];
    int fail[maxnode];
    int last[maxnode];
    int val[maxnode];//储存当前节点信息，如是否为单词节点等等
    int pos[110],cnt;//储存每个后缀或者自身是单词末尾的节点的位置
    int mp[110][110];//储存上述节点的最短路
    int dis[maxnode];//储存每一轮BFS所有点的 深度/到当前单词末节点距离
    int dp[1<<10+5][110];//dp[i][j]表示状态i下停在第j个单词节点的最短距离

    int newnode(int x){
        memset(trie[x],0,sizeof trie[x]);
        val[x] = 0;
        return sz++;
    }

    void init(){
        newnode(sz = 0);
    }

    int idx(char ch){//实际字符串转化为字典树对应节点，根据题目做出具体改变
        return ch-'0';
    }

    void insert(char *s,int op){
        int u = 0;
        for (int i=0;s[i];i++){
            int c = idx(s[i]);
            if (!trie[u][c]){
                trie[u][c] = newnode(sz);
            }
            u = trie[u][c];
        }
        if (op>0) val[u] |= op;//防止有相同串,应该不会有
        else val[u] = -1;
    }

    void build(){
        fail[0] = 0;
        for (int c=0;c<ALP;c++){
            int v = trie[0][c];
            if (v){
                que.push(v);
                fail[v] = 0;
                last[v] = 0;
            }
        }
        while (!que.empty()){
            int u = que.front();que.pop();
            for (int c=0;c<ALP;c++){
                int v = trie[u][c];
                if (!v){
                    trie[u][c] = trie[fail[u]][c];
                    continue;
                }
                fail[v] = trie[fail[u]][c];
                last[v] = val[fail[v]]>0? fail[v]:last[fail[v]];
                //下面这两行挺关键的
                if (val[fail[v]]==-1) val[v] = -1;
                else val[v] |= val[last[v]];
                que.push(v);
            }
        }
    }

    void BFS(int u){
        memset(dis,-1,sizeof dis);
        que.push(pos[u]);
        dis[pos[u]] = 0;
        while (!que.empty()){
            int now = que.front();que.pop();
            //pt(now,now);
            for0(c,0,2){
                int v = trie[now][c];
                if (dis[v]==-1 && val[v]!=-1){//只被更新一次因为按照BFS，第一次更新距离最短
                    dis[v] = dis[now]+1;
                    //pt(v,v);pt(dis[v],dis[v]);
                    que.push(v);
                }
            }
        }
        for (int i=0;i<cnt;i++)
            mp[u][i] = dis[pos[i]];//,pt(pos[i],pos[i]),pt(dis[pos[i]],dis[pos[i]]);
    }

    void solve(int n){
        //memset(mp,INF,sizeof mp);//不需要初始化，反正所有点都会在BFS结束后赋值
        cnt = 1;
        for0(i,0,sz)
            if (val[i]>0) pos[cnt++] = i;
        for0(i,0,cnt) BFS(i);

        memset(dp,INF,sizeof dp);
        dp[0][0] = 0;//只初始化这个表明从根节点开始
        for (int i=0;i<(1<<n);i++)
            for0(j,0,cnt){
                if (dp[i][j]==INF) continue;
                for0(k,0,cnt){
                    if (mp[j][k]<0) continue;
                    dp[i|val[pos[k]]][k] = min(dp[i|val[pos[k]]][k],dp[i][j]+mp[j][k]);
                }
            }

        int ans = INF;
        for0(i,0,cnt) ans = min(ans,dp[(1<<n)-1][i]);
        printf("%d\n",ans);
    }
}ac;

int main()
{
    //freopen("C:/Users/DELL/Desktop/input.txt", "r", stdin);
    //freopen("C:/Users/DELL/Desktop/output1.txt", "w", stdout);
    int n,m;
    while (~scanf("%d %d",&n,&m),n|m){
        ac.init();
        for0(i,0,n) scanf("%s",s),ac.insert(s,1<<i);
        for0(i,0,m) scanf("%s",s),ac.insert(s,-1);
        ac.build();
        ac.solve(n);
        //for0(i,0,ac.cnt){for0(j,0,ac.cnt)printf("mp[%d][%d]=%d ",i,j,ac.mp[i][j]);puts("");}
    }
    return 0;
}

总结：

ac自动机的fail只能跳当前后缀与字典树的最长前缀，沿着trie图走的话。

统计单词需要注意的两点

①漏后缀——即到达当前单词末尾其实相当于后缀的单词也走到了。构造的时候每个节点信息改为储存整个后缀链接上的所有字符,也就是这一个节点等价于所有实际已经到达的节点的效果。

②漏子串，其实就是单词的前缀漏掉后缀的问题。这些节点也当做单词末节点处理。

沿着trie图跑的话，任何情况下都要注意当前节点是否是末节点以及当前串的槲坠是否是末节点。