利用子集構造法實現NFA到DFA的轉換

• 概述

NFA非有窮自動機，即當前狀態識別某個轉換條件后到達的后繼狀態不唯一，這種自動機不便機械實現，而DFA是確定有限狀態的自動機，它的狀態轉換的條件是確定的，且狀態數目往往少於NFA，所以DFA能夠比較方便的機械實現且識別能力方面也和NFA相當。本次實驗采用子集構造法來實現不帶空弧的由NFA到DFA的轉換。

 

子集構造法的算法如下：

設NFA為M=(K,Σ,f,S0,Z)，則構造相應的DFA  M′=(Q,Σ,f′,I0,F)
①取I0=S0；
②對於狀態集Q中任一尚未標記的狀態qi={Si1,Si2,…,Sim},Sik∈K，做：
 (1) 標記qi；
 (2) 對於每個a∈Σ，置
     T=f({Si1,Si2,…,Sim},a)
     qj=εCLOSURE(T)
 (3) 若qj不在Q中，則將qj作為一個未加標記的狀態添加到Q中，且把狀態轉移f′(qi,a)=qj添加到M′。
③重復進行步驟②，直到Q中不再含有未標記的狀態為止。對於由此構造的Q，我們把那些至少含有一個Z中的元素的qi作為M′的終態。

 

對於如圖所示的NFA其在文件中保存的信息如下

 

轉成DFA之后的形式為

 

重命名為

• 程序整體思路

首先將文件中所給的NFA輸入讀入程序，在讀入過程中將其以圖的鄰接表的形式保存，其中將狀態轉移條件記為該邊的權值，每種狀態記為圖的結點，該狀態識別狀態轉移條件(權值)之后到達的狀態為該結點的鄰接點。

 

對於上面的例子，將其讀入程序中后該圖在程序中的邏輯存儲結構（圖的鄰接表）如圖所示，其中鄰接點中第一個數字表示權值，第二個數字表示所連的結點。

將圖讀入程序中后，再使用子集構造算法來完成由NFA到DFA的轉化。

 

對於每種狀態，其數據結構定義為

typedef struct state
{
    set<int> Set;
    char name;
}state;

其中set里存放該狀態識別某個條件后所能到達的狀態集合的下標，name里存該狀態重命名后的名字。

 

這些狀態保存在狀態數組States[max]中，狀態數組States[max]數據結構定義為

state States[max];

子集構造法的過程就是不斷向狀態數組States[ ]中，添加識別某個條件后，新的未出現的狀態的過程。

 

程序中函數說明

void creatph(algraph &g,FILE *fpr)：將文件內容讀入程序，並將其轉換為圖的鄰接表子函數。

int change(algraph g,char p)：將圖中結點轉化為對應下標子函數。

state move(state s,int n,algraph g)：求當前狀態集合的轉移集合，即求s狀態識別字母n之后的狀態集合。

int equalSet(state m,state n)：比較兩個狀態的set集合內容是否相等，不相等返回0，相等返回1。

void inStates(state &s)：判斷當前狀態是否在States數組中存在，若存在，進行改名；若不存在，改名后加入States數組。

void changeToD(algraph g,FILE *fpw)：由NFA轉到DFA的主控程序子函數。

程序輸入如下圖所示

 

程序輸出如下圖所示

 

•  代碼清單

#include<stdio.h>
#include<malloc.h>
#include <iostream>
#include <fstream>
#include <cstring>
#include<set>

using namespace std;

#define max 50//定義結點最大數量
typedef char vertype;//定義結點值域為字符類型
char buf[1024];//定義讀文件內容時，程序緩沖數組
int num;//記錄有窮字母表元素的個數
int length;//記錄States數組的長度

typedef struct arcnode//圖的邊信息
{
    int adjvex;
    int weight;//邊所對應的權值
    struct arcnode *next;
}arcnode;

typedef struct vnode//圖的結點類型定義
{
    vertype data;
    arcnode *next;
}vnode,adjlist[max];

typedef struct//圖的定義
{
    adjlist a;
    int vexnum,arcnum;
}algraph;

typedef struct state//狀態的定義
{
    set<int> Set;
    char name;
}state;

state States[max];

int change(algraph g,char p)//將圖中結點轉化為對應下標
{
    int i;
    for(i=0;i<g.vexnum;i++)
    {
        if(p==g.a[i].data)
            return i;
    }
    return -1;
}

void creatph(algraph &g,FILE *fpr)
{
    int line = 0;
    while(!feof(fpr))
    {    
        fgets(buf,1024,fpr);
        if(strlen(buf)>1)//獲取文件中圖的結點個數
        {    
            int i = 0;
            while(buf[i]==' ')
            {
                i++;
            }
            
            g.a[line].data=buf[i];
            g.a[line].next=NULL;
            line++;
        }
    }
    g.vexnum=line;
    
    rewind(fpr);//將文件指針返回到開頭位置
    line = 0;
        arcnode *s;

    while(!feof(fpr))//再次掃描文件將邊的信息添上，構造圖
    {    
        int weight=0;//邊所對應的權值,每一行權值都從0開始
        fgets(buf,1024,fpr);
        if(strlen(buf)>1)
        {
            for(int i=0;i<strlen(buf)-1;i++)
            {
                if(buf[i]=='{')
                {    
                    weight++;    
                    if(num<weight)
                        num=weight;

                    i++;    
                    if(buf[i]=='N')
                            i=i+4;

                    while(buf[i]!='}')
                    {    
                        if(buf[i]!=',')
                        {
                            //cout<<buf[i];////////////////////////////////
                            int x = change(g,buf[i]);

                            s=(arcnode *)malloc(sizeof(arcnode));
                            s->adjvex=x;
                            s->weight=weight;
                            s->next=g.a[line].next;
                            g.a[line].next=s;
                            //cout<<line;////////////////////////////////
                        }
                        i++;
                    }
                }
            }
            line++;
        }    
    }

}

state move(state s,int n,algraph g)//求當前狀態集合的轉移集合，即求s狀態識別字母n之后的狀態集合
{
    state temp;
    arcnode *m;
    set<int>::iterator itr;//迭代器
    for(itr = s.Set.begin();itr!=s.Set.end();itr++)//遍歷當前s狀態中集合元素 
    {
        int i = *itr;
        m = g.a[i].next;
        while(m)
        {
            if(m->weight==n)
            {
                temp.Set.insert(m->adjvex);//cout<<m->adjvex<<" ";
            //    temp.name=s.name+1;//cout<<temp.name<<endl;
            }
            m=m->next;
        }
    }
    return temp;    
}

int equalSet(state m,state n)//比較兩個狀態的set集合內容是否相等
{
    int flag = 1;
    if(m.Set.size()!=n.Set.size())
    {
        flag = 0;
        return flag;
    }

    set<int>::iterator itrm;
    set<int>::iterator itrn;
    for(itrm = m.Set.begin(),itrn = n.Set.begin();itrm!=m.Set.end();itrm++,itrn++)
    {
        int m = *itrm;
        int n = *itrn;

        if(m!=n)
        {
            flag = 0;
            break;
        }
    }
    return flag;
}

void inStates(state &s)//判斷當前狀態是否在States數組中存在，若存在，進行改名；若不存在，改名后加入States數組
{
    int flag = 0;
    if(length==0)
    {
        States[0]=s;
        States[0].name='A';
        length++;
    }
    else
    {
        for(int i=0;i<length;i++)
        {
            //cout<<equalSet(States[i],s);
            if(equalSet(States[i],s)==1)//若存在，進行改名
            {
                s.name=States[i].name;
                flag = 1;
                break;
            }
        }

        if(flag == 0)//若不存在，改名后加入States數組
        {
            s.name=States[length-1].name+1;
            States[length]=s;
            length++;
        }
    }
}

void changeToD(algraph g,FILE *fpw)
{
    state s,temp;
    s.Set.insert(0);
    s.name='A';

    inStates(s);

    for(int i=0;i<length;i++)
    {    
        cout<<"{";
        fprintf(fpw,"{");

        set<int>::iterator itr;//迭代器
        for(itr = States[i].Set.begin();itr!=States[i].Set.end();itr++)//遍歷當前s狀態中集合元素 
        {
            int i = *itr;
            cout<<g.a[i].data<<",";
            fprintf(fpw,"%c,",g.a[i].data);
        }

        cout<<"}";
        fprintf(fpw,"}");

        cout<<States[i].name;
        fprintf(fpw,"%c",States[i].name);

        for(int j=1;j<=num;j++)
        {
            temp = move(States[i],j,g);
            inStates(temp);    
            //查看temp狀態的set集合
            /*    
            set<int>::iterator itr;//迭代器
            for(itr = temp.Set.begin();itr!=temp.Set.end();itr++)//遍歷當前s狀態中集合元素 
            {
                int i = *itr;
                cout<<i<<" ";
            }*/    
            cout<<temp.name;
            fprintf(fpw,"%c",temp.name);    
        }
        cout<<endl;    
        fprintf(fpw,"\n");
    }
}


int main()
{
    algraph g;

    FILE *fpr = fopen("F:\\test.txt","r");
    FILE *fpw = fopen("F:\\testOutput.txt","w");
    

/*    FILE *fpr = fopen("test.txt","r");
    FILE *fpw = fopen("output.txt","w");*/

    creatph(g,fpr);

    //create測試
    /*
    for(int i=0;i<g.vexnum;i++)
    {
        cout<<g.a[i].data<<endl;//////////////////

    }
    */

    changeToD(g,fpw);
    //move測試
    /*
    state s;
    s.Set.insert(0);
    s.Set.insert(2);
    s.Set.insert(3);
    s.mark=1;
    s.name='B';

    move(s,2,g);
    */
    return 0;
}