[uva] 1671 History of Languages

题目描述

输入两个DFA，判断是否等价。

https://uva.onlinejudge.org/external/16/1671.pdf

输入

第一行T 可以接受的字母表
第二行N 状态数
接下去N行 每个状态的情况 第一个表示是否为接受状态 后面T个是接受字母i可以转移到的状态 -1表示不转移

输出

等价输出Yes，不等价输出No

样例输入

2
3
1 -1 1
0 -1 2
0 -1 0
2
1 -1 1
0 -1 0
3
4
1 -1 -1 1
1 -1 -1 2
1 -1 -1 3
1 -1 -1 1
2
1 -1 -1 1
1 -1 -1 0
0

样例输出

Case #1: No
Case #2: Yes

思路

参考刘神的思路，求DFA2的补，然后与DFA1测试相交。如果不相交，当然是等价。

求补的思路就是把接受状态全都取反。求相交的思路就是BFS，或者DFS。我用的是BFS，很快，复杂度O(n)。

一个重要的细节，我在这上面卡了很久，就是怎么处理-1的情况。最后的解法是设一个孤岛结点，孤岛的所有转移都指向自己，-1的情况就转移到孤岛，孤岛自己不是接受状态。这样做的正确性：原DFA可以接受的状态集没有改变。因为我只需要知道那些输入可以接受，其余的就是不接受的输入。

但是如果不要孤岛，怎么直接处理-1的情况？

首先，如果遇到-1直接pass，那么处理不了

DFA1: 1->2->3->4->5(ac)

DFA2: 1->2->3->4->5(ac)->6(ac)

或者

DFA2: 1->2->3->4->5(ac)->6->7-> ... ->n(ac)

而且，处理起来很麻烦，情况很多，所以还是加个孤岛结点吧。

实现

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;

const int maxn = 2010;  // size of state
const int maxm = 30;    // size of alphabet

int T;      // T <= 26
int n1, n2; // n <= 2000
bool is_final1[maxn], is_final2[maxn];
int dfa1[maxn][maxm], dfa2[maxn][maxm];

bool init()
{
    scanf("%d", &T);
    if (T == 0)
        return false;

    scanf("%d", &n1);
    for (int i = 0; i < n1; i++) {
        int f1;
        scanf("%d", &f1);
        is_final1[i] = ((f1 == 1) ? true : false);
        for (int j = 0; j < T; j++) {
            scanf("%d", &dfa1[i][j]);
            dfa1[n1][j] = n1;
            if (dfa1[i][j] == -1) // 孤岛状态
                dfa1[i][j] = n1;
        }
    }
    is_final1[n1] = 0; // 孤岛

    scanf("%d", &n2);
    for (int i = 0; i < n2; i++) {
        int f2;
        scanf("%d", &f2);
        is_final2[i] = ((f2 == 1) ? true : false);
        for (int j = 0; j < T; j++) {
            scanf("%d", &dfa2[i][j]);
            dfa2[n2][j] = n2;
            if (dfa2[i][j] == -1) // 孤岛状态
                dfa2[i][j] = n2;
        }
    }
    is_final2[n2] = 0;
    return true;
}

bool visit[maxn][maxn];
bool bfs(int a1[maxn][maxm], int a2[maxn][maxm], bool b1[maxn], bool b2[maxn])
{
    memset(visit, false, sizeof visit);
    queue<pair<int,int> > Q;

    Q.push(make_pair(0, 0));
    visit[0][0] = true;

    while (!Q.empty()) {
        pair<int,int> P = Q.front();
        Q.pop();
        if (b1[P.first] && !b2[P.second]) // 2求补集
            return true;              // 发现相交

        for (int i = 0; i < T; i++) {
            // bfs 遍历未访问转移状态
            if (visit[a1[P.first][i]][a2[P.second][i]] == false) {
                visit[a1[P.first][i]][a2[P.second][i]] = true;
                Q.push(make_pair(a1[P.first][i], a2[P.second][i]));
            }
        }
    }
    return false; // 不相交
}

int main()
{
    int kase = 0;
    while (init()) {
        printf("Case #%d: ", ++kase);
        if (!bfs(dfa1, dfa2, is_final1, is_final2)
            && !bfs(dfa2, dfa1, is_final2, is_final1))
            printf("Yes\n");
        else
            printf("No\n");
    }
    return 0;
}

原文地址：https://www.cnblogs.com/trav/p/10483951.html