期末作业代码

#include<iostream>
#include<cstring>
#include<stack>
#include<vector>
#include <map>
#include <algorithm>
using namespace std;

#define N 1000

//正则表达式到NAF的实现
int state = 0;	//记录状态 
stack<char> mark;	//存放要处理的符号
stack< pair<int,int> > sub;	//存放子正则表达式
vector<int> chat[N][27];	//正则表达式到NAF的转换表 
string add = "abcdefghijklmnopqrstuvwxyz)*+?E";

void nfaletter(char letter){
	pair<int,int> temp;
	temp.first = state++;
	temp.second = state++;
	if(letter == 'E')
		chat[temp.first][26].push_back(temp.second);
	else{
		int t = letter - 'a';
		chat[temp.first][t].push_back(temp.second);
	}
	sub.push(temp);
} 
//*的构造
void nfamark1(){
	pair<int,int> temp;
	temp.first = state++;
	temp.second = state++;
	pair<int,int> last = sub.top();
	chat[temp.first][26].push_back(last.first);
	chat[temp.first][26].push_back(temp.second);
	chat[last.second][26].push_back(last.first);
	chat[last.second][26].push_back(temp.second);
	sub.pop();
	sub.push(temp);
}
//?的构造
void nfamark2(){
	pair<int,int> temp;
	temp.first = state++;
	temp.second = state++;
	pair<int,int> last = sub.top();
	chat[temp.first][26].push_back(last.first);
	chat[temp.first][26].push_back(temp.second);
	chat[last.second][26].push_back(temp.second);
	sub.pop();
	sub.push(temp);
} 
//+的构造
void nfamark3(){
	pair<int,int> temp;
	temp.first = state++;
	temp.second = state++;
	pair<int,int> last = sub.top();
	chat[temp.first][26].push_back(last.first);
	chat[last.second][26].push_back(last.first);
	chat[last.second][26].push_back(temp.second);
	sub.pop();
	sub.push(temp);
} 
//|的构造
void nfamark4(){
	pair<int,int> temp;
	temp.first = state++;
	temp.second = state++; 
	pair<int,int> obj1 = sub.top();
	sub.pop();
	pair<int,int> obj2 = sub.top();
	sub.pop();
	chat[temp.first][26].push_back(obj1.first);
	chat[temp.first][26].push_back(obj2.first);
	chat[obj1.second][26].push_back(temp.second);
	chat[obj2.second][26].push_back(temp.second);
	sub.push(temp);
} 
//&的构造
void nfamark5(){
	pair<int,int> temp;
	pair<int,int> obj2 = sub.top();
	sub.pop();
	pair<int,int> obj1 = sub.top();
	sub.pop();
	temp.first = obj1.first;
	temp.second = obj2.second;
	chat[obj1.second][26].push_back(obj2.first);
	sub.push(temp);
} 
void initial(){
	state = 0;
	while(mark.empty() != true)
		mark.pop();
	while(sub.empty() != true)
		sub.pop();
	for(int i = 0;i < N;i++){
		for(int t = 0;t < 27;t++)
			chat[i][t].clear();
	}
}
//判断前面是否是连接符号 
int belong(char letter){
	int len = add.length();
	int i;
	for(i = 0;i < len;i++){
		if(add[i] == letter){
			return 1;
		}
	}
	return 0;
}
void Expre_To_NFA(string expre){
	initial();
	int len = expre.length();
	
	for(int i = 0;i < len;i++){
		if(isalpha(expre[i])){
			//判断是否要压入'&'的符号
			 if(i > 0 && belong(expre[i-1])){
			 	if(mark.empty() == false && mark.top() == '&'){
			 		mark.pop();
			 		nfamark5();	
				 }
				 mark.push('&');
			}
			nfaletter(expre[i]);
		}
		else if(expre[i] == '*'){
			nfamark1();
		}
		else if(expre[i] == '?'){
			nfamark2();
		}
		else if(expre[i] == '+'){
			nfamark3();
		}
		else if(expre[i] == '|'){
			if(mark.empty() == true) 
				mark.push('|');
			else if((mark.empty() != true && mark.top() == '('))
				mark.push('|');
			else{
				if(mark.top() == '|')
					nfamark4();
				else if(mark.top() == '&')
					nfamark5();
				mark.pop();
				mark.push('|');	
			}
		}
		else if(expre[i] == '('){
			 if(i > 0 && belong(expre[i-1])){
			 	if(mark.empty() == false && mark.top() == '&'){
			 		mark.pop();
			 		nfamark5();
				 }
				 mark.push('&');
			}
			mark.push('(');			
		}
		else if(expre[i] == ')'){
			while(mark.top() != '('){
				if(mark.top() == '|')
					nfamark4();
				else if(mark.top() == '&')
					nfamark5();
				mark.pop();
			}
			mark.pop();	//pop出右括号 
		}
	}
	while(mark.empty() == false){
		if(mark.top() == '|')
			nfamark4();
		else if(mark.top() == '&')
			nfamark5();
		mark.pop();
	} 
	//cout<<"2"<<endl;
} 
/*输出NFA的各项数据*/
void show() {
    cout << "**********第一步：NFA各项数据如下***************\n";
    pair<int, int> r = sub.top();
    cout << "状态数：" << state << "\t";
    cout << "开始状态：" << r.first << "\t" << "接受状态：" << r.second << endl;
    cout << "\ta\tb\tc\td\te\tf\tg\th\ti\tj\tk\tl\tm\n";
    for ( unsigned i = 0; i < state; i++ ) {
        cout << i << ":\t";
        for ( unsigned j = 0; j < 13; j++ ) {
			sort( chat[ i ][ j ].begin(), chat[ i ][ j ].end() );
            cout << "{";
            for ( unsigned k = 0; k < chat[ i ][ j ].size(); k++ ) {
                cout << chat[ i ][ j ][ k ];
				if ( k + 1 != chat[ i ][ j ].size() )
					cout << ",";
			}
            cout << "}\t";
        }
        cout << endl;
    }
    cout<<endl;
    cout << "\tn\to\tp\tq\tr\ts\tt\tu\tv\tw\tx\ty\tz\tε\n";
    for ( unsigned i = 0; i < state; i++ ) {
        cout << i << ":\t";
        for ( unsigned j = 13; j < 27; j++ ) {
			sort( chat[ i ][ j ].begin(), chat[ i ][ j ].end() );
            cout << "{";
            for ( unsigned k = 0; k < chat[ i ][ j ].size(); k++ ) {
                cout << chat[ i ][ j ][ k ];
				if ( k + 1 != chat[ i ][ j ].size() )
					cout << ",";
			}
            cout << "}\t";
        }
        cout << endl;
    }
}


//NAF到DFA的实现
vector< vector<int> > Dstates;	//存放DFA的状态
map< vector<int>, int> mapping; 	//存放NFA和DFA状态的一个映射关系 
int state1;		//DFA的状态
vector<int> ending;		//记录接收状态 
int chat1[N][27];		//DFA的状态转换
vector<int> E_closure(vector<int> temp){
	vector<int> re(temp.begin(),temp.end());
	stack<int> s;
	for(int i = 0;i < temp.size();i++)
		s.push(temp[i]);
	while(s.empty() == false){
		int f = s.top();
		s.pop();
		vector<int> obj(chat[f][26].begin(),chat[f][26].end());
		for(int t = 0;t < obj.size();t++){
			if(find(re.begin(),re.end(),obj[t]) == re.end()){
				re.push_back(obj[t]);
				s.push(obj[t]);
			}

		}
	}
	sort(re.begin(),re.end());
	return re;
} 
vector<int> move(vector<int> temp, int a){
	vector<int> re;
	for(int i = 0;i < temp.size();i++){
		vector<int> temp1(chat[temp[i]][a].begin(),chat[temp[i]][a].end());
		for(int t = 0;t < temp1.size();t++){
			if(find(re.begin(),re.end(),temp1[t]) == re.end())
				re.push_back(temp1[t]);
		}
	}
	return re;
}
void initial1(){
	state1 = 0;
	Dstates.clear();
	mapping.clear(); 
	ending.clear();
	for(int i = 0;i < N;i++){
		for(int t = 0;t < 27;t++)
			chat1[i][t] = 0;
	}
}
vector<int> find_ending(int state){
	vector<int> re;
	for(int i = 0;i < Dstates.size();i++){
		if(find(Dstates[i].begin(),Dstates[i].end(),state) != Dstates[i].end()){
			re.push_back(mapping[Dstates[i]]);
		}
	}
	sort(re.begin(),re.end());
	return re;
}
void NFA_To_DFA(){
	
	initial1();
	//计算开始状态的闭包
	pair<int,int> re = sub.top();
	vector<int> s,t;	//作为计算闭包前和计算闭包后的容器 
	s.push_back(re.first);
	t = E_closure(s);
	//cout<<"in"<<endl;
	Dstates.push_back(t);
	mapping[t] = state1++;

	stack< vector<int> > sta;	//栈中存放未标记的Dstates 
	sta.push(t);
	
	while(sta.empty() != true){
		//cout<<"loop"<<endl;
		s = sta.top();
		sta.pop();
		for(int i = 0;i < 26;i++){
			t = E_closure(move(s,i));
			//如果得到的是空集的情况下，表格中填写-1 
			if(t.size() == 0){
				chat1[mapping[s]][i] = -1;
				continue;
			}
			//如果得到的不是空集，则继续计算 
			if(find(Dstates.begin(),Dstates.end(),t) == Dstates.end()){
				Dstates.push_back(t);
				mapping[t] = state1++;
				sta.push(t);
			}
			chat1[mapping[s]][i] = mapping[t];
		}
	}
	ending = find_ending(re.second);
}
/*输出DFA的各项数据*/
void show1() {
    cout << "**********第二步：DFA各项数据如下***************\n";
    cout << "状态数：" << state1 << "\t";
    cout << "开始状态：" << 0 << "\t" << "接受状态：";
    for ( unsigned i = 0; i < ending.size(); i++ )
        cout << ending[ i ] << " ";
    cout << endl;
    cout << "\ta\tb\tc\td\te\tf\tg\th\ti\tj\tk\tl\tm\n";
    for ( unsigned i = 0; i < state1; i++ ) {
        cout << i << ":\t";
        for ( int j = 0; j < 13; j++ )
            cout << chat1[ i ][ j ] << "\t";
        cout << endl;
    }
    cout<<endl;
    cout << "\tn\to\tp\tq\tr\ts\tt\tu\tv\tw\tx\ty\tz\n";
    for ( unsigned i = 0; i < state1; i++ ) {
        cout << i << ":\t";
        for ( int j = 13; j < 26; j++ )
            cout << chat1[ i ][ j ] << "\t";
        cout << endl;
    }
}


//DFA最小化的实现 
vector< vector<int> > P,nP;		//两个划分：初始划分和新划分
vector<int> ending1;	//接受状态
int chat2[N][27];		//最小化后的DFA的状态转移表
int mapping1[N];		//原来的状态到最小化后的DFA状态之间的映射
int start;				//记录开始状态 
int state2;				//记录状态数目 
int groups[N][27];		//标记在不同输入时得到的子分组号 
void initial3(){
	state2 = 0; 
	P.clear();
	nP.clear();
	ending1.clear();
	memset(groups,0,sizeof(groups));
}
void group(int v){
	//输入P[v]为要判断的子集对象
	vector<int>	temp;	//每个子分组的容器
	int done[N];	//对状态是否进行分组进行标记，0为没有分组，1为分组 
	memset(done,0,sizeof(done));
	
	for(int i = 0;i < P[v].size();i++){
		for(int j = 0;j < 26;j++){
			int obj = chat1[P[v][i]][j];
			if(obj != -1){
				for(int m = 0;m < P.size();m++){
					if(find(P[m].begin(),P[m].end(),obj) != P[m].end()){
						groups[P[v][i]][j] = m;
						break; 
					}
				}				
			}
			else groups[P[v][i]][j] = -1; 
		}
	} 
	//进行整理，将同一状态的进行合并
	for(int i = 0;i < P[v].size();i++){
		if(done[P[v][i]] == 0){
			done[P[v][i]] = 1;
			temp.clear();
			temp.push_back(P[v][i]);
			for(int j = i + 1; j < P[v].size();j++){
				if(done[P[v][j]] == 0){
					int k;
					for(k = 0;k < 26;k++){
						if(groups[P[v][i]][k] != groups[P[v][j]][k])
							break;
					}
					if(k == 26){
						temp.push_back(P[v][j]);
						done[P[v][j]] = 1;
					}
				}
			}
			nP.push_back(temp);
		}
	} 
} 
void DFA_To_Min(){
	initial3();
	//利用接受状态和非接受状态进行分组
	vector<int> temp1;
	vector<int> temp2;
	for(int i = 0;i < state1;i++){
		if(find(ending.begin(),ending.end(),i) == ending.end())
			temp1.push_back(i);
		else
			temp2.push_back(i);
	}
	if(temp1.size() != 0)
		nP.push_back(temp1);
	if(temp2.size() != 0)
		nP.push_back(temp2);
	
	//对每个子集进行单个输入的判断，其接受状态是否处于其他的子集中 
	while(P.size() != nP.size()){
		P = nP;
		nP.clear();
		for(int i = 0;i < P.size();i++)
			group(i);
	}
	
	//DFA到最小化DFA之间的关系
	for(int i = 0;i < P.size();i++){
		for(int j = 0;j < P[i].size();j++){
			mapping1[P[i][j]] = state2;
			if(P[i][j] == 0)	
				start = state2; 
		}
		state2++;
	} 
	
	//得到最后的接受状态
	for(int i = 0;i < ending.size();i++){
		if(find(ending1.begin(),ending1.end(),mapping1[ending[i]]) == ending1.end())
			ending1.push_back(mapping1[ending[i]]);
	} 
	
	//构造状态转换表
	 vector<int> v;
	 v.clear();
	 for(int i = 0;i < P.size();i++){
	 	v.push_back(P[i][0]);
	 } 

	 for(int i = 0;i < v.size();i++){
	 	for(int j = 0;j < 26;j++)
	 		if(chat1[v[i]][j] != -1)
	 			chat2[mapping1[v[i]]][j] = mapping1[chat1[v[i]][j]];
	 		else 
	 			chat2[mapping1[v[i]]][j] = -1;
	 }
	 
}
/*输出最小化DFA*/
void show2() {
    cout << "**********第三步：MIN各项数据如下***************\n";
    cout << "状态数：" << state2 << "\t";
    cout << "开始状态：" << start << "\t" << "接受状态：";
    for ( vector<int>::iterator it = ending1.begin(); it != ending1.end(); it++ )
        cout << *it << " ";
    cout << endl;
    cout << "\ta\tb\tc\td\te\tf\tg\th\ti\tj\tk\tl\tm\n";
    for ( int i = 0; i < state2; i++ ) {
        cout << i << ":\t";
        for ( int j = 0; j < 13; j++ )
            cout << chat2[ i ][ j ] << "\t";
        cout << endl;
    }
    cout << "\tn\to\tp\tq\tr\ts\tt\tu\tv\tw\tx\ty\tz\n";
    for ( int i = 0; i < state2; i++ ) {
        cout << i << ":\t";
        for ( int j = 13; j < 26; j++ )
            cout << chat2[ i ][ j ] << "\t";
        cout << endl;
    }
}


//两个最小化后的DFA的比较 
int f_state,s_state;	//两个状态数目
int	f_start,s_start;	//两个开始状态
vector<int>	f_ending,s_ending;	//两个接受状态集合
int	f_chat[N][27],s_chat[N][27];	//两个DFA的状态转移表格 
int layer = 0;
int f_visit[N];
int s_visit[N];	
int c1,c2,c3,c4;
int cycle[500][500];

void Expre_To_DFA(string expre1,string expre2){
//		cout<<"first one::"<<endl;
		Expre_To_NFA(expre1);
//		show();
		NFA_To_DFA();
//		show1();
		DFA_To_Min();
//		show2();
		f_state = state2;
		f_start = start;
		f_ending = ending1;
		memcpy(f_chat,chat2,sizeof(chat2));
		
//		cout<<"second one::"<<endl;
		Expre_To_NFA(expre2);
//		show();
		NFA_To_DFA();
//		show1();
		DFA_To_Min();
//		show2();
		s_state = state2;
		s_start = start;
		s_ending = ending1;
		memcpy(s_chat,chat2,sizeof(chat2));			
}

void search1(int f_start,int s_start){
		if(find(f_ending.begin(),f_ending.end(),f_start) != f_ending.end()){
			c1++;
			if(find(s_ending.begin(),s_ending.end(),s_start) != s_ending.end())
				c2++;
		} 
		if(find(s_ending.begin(),s_ending.end(),s_start) != s_ending.end()){
			c3++;
			if(find(f_ending.begin(),f_ending.end(),f_start) != f_ending.end())
				c4++;
		} 
	//cout<<f_start<<" "<<s_start<<" "<<c1<<" "<<c2<<" "<<c3<<" "<<c4<<endl;
	if(f_start == -1 || s_start == -1) return;
	cycle[f_start][s_start] += 1;
	if(cycle[f_start][s_start] > 50) return;
	layer++;
	f_visit[f_start] = layer;
	s_visit[s_start] = layer; 
	for(int i = 0;i < 26;i++){				
		int obj1 = f_chat[f_start][i];
		int obj2 = s_chat[s_start][i];
		//一定不相等
		if(obj1 == -1 && obj2 == -1)
			continue;
		else if(obj1 == -1 || obj2 == -1)
			search1(obj1,obj2);
		else if((!(f_visit[obj1] > 0  && s_visit[obj2] > 0)) || (f_visit[obj1] != s_visit[obj2])){
			search1(obj1,obj2);
		}
	}
	layer--;
	return; 
}


int main(){
	int n;
	cin>>n; 
	for(int i = 0;i < n;i++){
		string obj1;
		string obj2;
		cin>>obj1>>obj2;
		Expre_To_DFA(obj1,obj2);
		
		memset(f_visit,-1,sizeof(f_visit));
		memset(s_visit,-1,sizeof(s_visit));		
		memset(cycle,0,sizeof(cycle));
		int equal = -1;	//1表示相同，2表示>，3表示< ,4表示其他情况 
		//判断是否相同
		c1 = 0;
		c2 = 0;
		c3 = 0;
		c4 = 0;
		search1(f_start,s_start);
//		cout<<c1<<" "<<c2<<" "<<c3<<" "<<c4<<endl;
		if(c1 == 0 && c2 == 0 && c3 == 0 && c4 == 0)	cout<<"!"<<endl;
		else if(c1 == c2 && c3 == c4) cout<<"="<<endl;
		else if(c1 == c2 && c3 > c4) cout<<"<"<<endl;
		else if(c1 > c2 && c3 == c4) cout<<">"<<endl;
		else cout<<"!"<<endl;
	}
}