欧拉回路算法

#include <iostream>
#include <cstring>
#include <stack>
#include <queue>
using namespace std;

#define MAPSIZE 100
#define STARTNODE 1

bool g_bVisit[MAPSIZE];
int g_nGraph[MAPSIZE][MAPSIZE];

int g_nVNum;
int g_nENum;
int g_nStackSize;
int g_bFind;

void initGraph();
void Euler();
void DFS( int, stack< int >& );
bool isContected();
bool isExistEulerRoad();
void printPath( stack< int >& );


int main(){
    
    int nCase;
    
	cout << "Enter CaseNum: ";
	cin >> nCase;
	
	while( nCase-- ){
	    
		memset( g_bVisit, false, sizeof( g_bVisit ) );
		memset( g_nGraph, 0,     sizeof( g_nGraph ) );
		
		cout << "Enter VNum And ENum: ";
		cin >> g_nVNum >> g_nENum;
		
		initGraph();
		
		if( !isExistEulerRoad() ){
		    
			cout << "Not Exist Euler Road!" << endl;
			continue;
			
		}
		
		if( !isContected() ){
		    
			cout << "The Graph Is Not Contected!" << endl;
			continue;
			
		}
		
		Euler();
	}
	
	return 0;
	
}


void initGraph(){
    
	for( int i = 1; i <= g_nENum; ++i ){
	    
	    int nStart,nEnd;
		cout << "Enter Start And End: ";
		cin >> nStart >> nEnd;
		
		g_nGraph[nStart][nEnd] = g_nGraph[nEnd][nStart] = 1;
		
	}
}


bool isExistEulerRoad(){
    
	for( int i = 1; i <= g_nVNum; ++i ){
	    
		int nSum = 0;
		
		for( int j = 1; j <= g_nVNum; ++j )
			nSum += g_nGraph[i][j];
		
		if( nSum % 2 != 0 )
            return false;
            
	}
	
	return true;
	
}


bool isContected(){
    
	queue< int > Q;
	
	Q.push( STARTNODE );
	g_bVisit[STARTNODE] = true;
	
	while( !Q.empty() ){
	    
		int temp = Q.front();
		Q.pop();
		
		for( int i = 1; i <= g_nVNum; ++i ){
			if( g_bVisit[i] == false && g_nGraph[temp][i] == 1 ){
				g_bVisit[i] = true;
				Q.push( i );
			}
		}
	}
	
	for( int i = 1; i <= g_nVNum; ++i ){
	    
		if( g_bVisit[i] == false )
            return false;
            
	}
	
	return true;
	
}


void Euler(){
    
    memset( g_bVisit, false, sizeof( g_bVisit ) );
	stack< int > S;
	
	cout << "Euler Road: ";
	
	S.push( STARTNODE );
	g_bVisit[STARTNODE] = true;
	g_bFind             = false;
	g_nStackSize        = g_nENum + 1;
	
	DFS( STARTNODE, S );
	printPath( S );
	
}


void DFS( int nStart, stack< int >& S ){
    
	if( nStart == STARTNODE && S.size() != g_nStackSize && S.size() != 1 ) 
        return ;
        
	if( nStart == STARTNODE && S.size() == g_nStackSize ){
	    
		g_bFind = true;
		return ;
		
	}
	
	for( int i = 1; i <= g_nVNum; ++i ){
		if( g_nGraph[nStart][i] == 1 ){
		    
			g_nGraph[nStart][i] = g_nGraph[i][nStart] = 0;
			
			S.push( i );
			DFS( i, S );
			
			if( g_bFind == true ) 
                return ;
                
			S.pop();
			g_nGraph[nStart][i] = g_nGraph[i][nStart] = 1;
			
		}
	}
}


void printPath( stack< int >& S ){
    
	while( !S.empty() ){
	    
		int top = S.top();
		S.pop();
		
		cout << top << "-->";
		
	}
	
	cout << "\n\n";
	
}