UVA - 11604 General Sultan(构图暴力)

题目大意：给出n个字符串（01串），问是否存在一个二进制序列，存在至少两种编码方式

比如{a = 01011111, b = 0101, c = 1111010, d = 010}

二进制序列01011111010就有两种编码方式了，可以由a＋d组成，也可以由b＋c＋d组成(注意这里的二进制序列不是指所给的武器的二进制序列，刚开始没理解。。被坑了)

解题思路：这样就比较好理解了，字符串匹配，不断的匹配

首先为每个字符都构建一个点，那怎么连边呢？

找匹配的部分进行连边，假设有两个字符串i，j，现在从字符串i的s位置往后开始和字符串j开始匹配，那么就有四种匹配结果了(以下的i字符串均指s位置后面的字符部分，id[i][j]指字符串i的第j个字符串的点标记，从0开始)

1. 两个字符串都刚好匹配完了，那就表明字符串i从s位置往后可以由j字符串组成，说明字符串i如果能匹配到s，那么就必然能匹配完，所以可以将id[i][s]这个点连向终点了
2. i字符串没匹配完，j字符串匹配完了，那么下一个点就是从id[i][s+字符串j的长度]匹配了，所以id[i][s] 和id[i][i+字符串j的长度]连边
3. j字符串没匹配完，i字符串匹配完了，那么下一个匹配点就是j字符串和i字符串匹配的结束位置＋1，所以id[i][s]和id[j][匹配结束位置]连边
4. 两个字符串都没有匹配完，那么就不会重了

现在的问题就转化成了，从任意一个字符串的起点出发，如果能走到终点的话，就表明存在字符串有两种编码方式

如果不太理解的话，可以画字符串的四种匹配情况的图

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 110
#define L 25
#define M 2500
#define S 250010

struct Edge {
    int to, next;
}E[S];

int n, End, tot;
int id[N][L], head[M], len[N];
char weapon[N][L];
bool vis[M];

void AddEdge(int u, int v) {
    E[tot].to = v;
    E[tot].next = head[u];
    head[u] = tot++;
}

void init() {
    memset(head, -1, sizeof(head));
    tot = 0;

    int k = 0;
    for (int i = 1; i <= n; i++) {
        scanf("%s%s", weapon[i], weapon[i]);
        len[i] = strlen(weapon[i]);
        for (int j = 0; j < len[i]; j++)
            id[i][j] = k++;
    }
    End = k;

    for (int i = 1; i <= n; i++)
         for (int s = 0; s <= len[i]; s++)
             for (int j = 1; j <= n; j++) {
                 if (i == j)
                     continue;
                 int t = 0;
                 for (t = 0; t <= len[j] && s + t <= len[i]; t++)
                     if (weapon[i][s + t] != weapon[j][t])
                         break;
                 if (t >= len[j] && s + t >= len[i])
                     AddEdge(id[i][s], End);
                 else if(t >= len[j])
                     AddEdge(id[i][s], id[i][s + t]);
                 else if(s + t >= len[i])
                     AddEdge(id[i][s], id[j][t]);
             }
}

bool flag;

void dfs(int u) {
    if (u == End) {
        flag = true;
        return;
    }

    vis[u] = true;
    for (int i = head[u]; i != -1; i = E[i].next) {
        int v = E[i].to;
        if (!vis[v])
            dfs(v);
        if (flag)
            return ;
    }
}

int cas = 1;
void solve() {
    memset(vis, 0, sizeof(vis));
    flag = false;
    for (int i = 1; i <= n; i++) {
        if (!vis[id[i][0]])
            dfs(id[i][0]);
        if (flag) break;
    }
    if (!flag)
        printf("Case #%d: Not ambiguous.\n", cas++);
    else
        printf("Case #%d: Ambiguous.\n", cas++);

}

int main() {
    while (scanf("%d", &n) != EOF && n) {
        init();
        solve();
    }
    return 0;
}

版权声明：本文为博主原创文章，未经博主允许不得转载。