General Sultan UVA

给出n个字符串，询问是否存在一个字符串（可以是给出的几个中的 也可以是组合成的），使得用字符串（随便你用多少个）来拼凑这个串，能够至少有两种拼法

解析：

　　把每一个字符串的每一个位置的字符看作结点，进行建边

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. 两个字符串都没有匹配完，那么就不会重了

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

原文地址https://blog.csdn.net/l123012013048/article/details/47374503

#include <iostream>
#include <cstdio>
#include <sstream>
#include <cstring>
#include <map>
#include <set>
#include <vector>
#include <stack>
#include <queue>
#include <algorithm>
#include <cmath>
#define rap(i, a, n) for(int i=a; i<=n; i++)
#define MOD 2018
#define LL long long
#define ULL unsigned long long
#define Pair pair<int, int>
#define mem(a, b) memset(a, b, sizeof(a))
#define _  ios_base::sync_with_stdio(0),cin.tie(0)
//freopen("1.txt", "r", stdin);
using namespace std;
const int maxn = 10010, INF = 0x7fffffff;
int cnt, n, tt, flag;
int head[maxn], vis[maxn], id[110][25], len[maxn];
char str[110][25];
struct node
{
    int v, next;
}Node[maxn*25];

void add(int u, int v)
{
    Node[cnt].v = v;
    Node[cnt].next = head[u];
    head[u] = cnt++;
}

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

    }
}
void init()
{
    mem(head, -1);
    mem(vis, 0);
    cnt = 0;

}
int main()
{
    int kase = 0;
    while(~scanf("%d", &n) && n)
    {
        init();
        int k = 0;
        rap(i, 1, n)
        {
            scanf("%s%s", str[i], str[i]);
            len[i] = strlen(str[i]);
            rap(j, 0, len[i]-1)
                id[i][j] = k++;
        }
        tt = k;
        rap(i, 1, n)
        {
            rap(s, 0, len[i])
            {
                rap(j, 1, n)
                {
                    if(i == j) continue;
                    int t = 0;
                    for(t=0; t <= len[j] && t+s <= len[i]; t++)
                        if(str[i][s+t] != str[j][t])
                            break;
                    if(t >= len[j] && t+s >= len[i])
                        add(id[i][s], tt);
                    else if(t >= len[j])
                        add(id[i][s], id[i][s+t]);
                    else if(t+s >= len[i])
                        add(id[i][s], id[j][t]);
                }
            }
        }
        flag = 0;
        rap(i, 1, n)
        {
            if(!vis[id[i][0]])
                dfs(id[i][0]);
            if(flag) break;
        }
        if(flag)
            printf("Case #%d: Ambiguous.
", ++kase);
        else
            printf("Case #%d: Not ambiguous.
", ++kase);

    }


    return 0;
}