main(int argc, char *argv[]) {
if (argc != 2) fatal("usage: cgraph type");
string s;
if (strcmp(argv[1],"graph") == 0) {
Graph g; g.read(cin); Graph g1(1,1);
g1.copyFrom(g); cout << g1.toString(s);
} else if (strcmp(argv[1],"wgraph") == 0) {
Wgraph wg; wg.read(cin); Wgraph wg1(1,1);
wg1.copyFrom(wg); cout << wg1.toString(s);
} else if (strcmp(argv[1],"digraph") == 0) {
Digraph dig; dig.read(cin); Digraph dig1(1,1);
dig1.copyFrom(dig); cout << dig1.toString(s);
} else if (strcmp(argv[1],"wdigraph") == 0) {
Wdigraph wdig; wdig.read(cin); Wdigraph wdig1(1,1);
wdig1.copyFrom(wdig); cout << wdig1.toString(s);
} else if (strcmp(argv[1],"flograph") == 0) {
Flograph fg; fg.read(cin); Flograph fg1(2,1);
fg1.copyFrom(fg); cout << fg1.toString(s);
} else if (strcmp(argv[1],"wflograph") == 0) {
Wflograph wfg; wfg.read(cin); Wflograph wfg1(2,1);
wfg1.copyFrom(wfg); cout << wfg1.toString(s);
} else {
fatal("usage: cgraph type");
}
}
Digraph< int > createTinyDigraph( void )
{
Array< int > edges = {
0, 1,
0, 5,
0, 6,
2, 0,
2, 3,
3, 5,
5, 4,
6, 4,
6, 9,
7, 6,
8, 7,
9, 10,
9, 11,
9, 12,
11, 12,
};
Digraph< int > d;
for ( int i = 0; i < edges.size() / 2; i++ ) {
d.addEdge( edges[ i * 2 ], edges[ i * 2 + 1 ] );
}
return d;
}
int main()
{
srand((unsigned int)time(NULL));
//srand(2);
Digraph<VertexBase> myDigraph;
// ExcThrower<Exception>::Throw(0.6, "Wyjatek z pawdopodobnienstwem 0.6");
myDigraph.generate(100);
cout << myDigraph << endl ;
ofstream output("../graf.txt");
if( output.is_open() )
{
while (myDigraph.shortenCriticalPath()){
cout << myDigraph << endl;
try{
myDigraph.SaveStructure(output);
}catch(FileWriteException& fwEx)
{
cout << fwEx.getMessage() << " numer wyjatku " << fwEx.Count() << endl;
}
}
output.close();
}
system("pause");
return 0;
}
Digraph* Digraph::reverse() {
Digraph* dg = new Digraph(n(), e());
for (int v = 0; v < n(); v++)
for (int w = first(v); w < n(); w = next(v, w))
dg->addEdge(w, v, getWeight(v, w));
return dg;
}
/* @brief breadth first search to compute bfs tree(forest)
* @param g digraph
* @param sources vertices to start
*
* @note may be not the shortest path
*/
void BFSDirectedPaths::bfs(const Digraph &g, const vector<int> &sources){
queue<int> q;
int sz = sources.size();
for(int i=0; i<sz; ++i){
int v = sources[i];
marked[v] = true;
distTo[v] = 0;
edgeTo[v] = v;
q.push(v);
}
while( !q.empty() ){
int v = q.front();
list<int>::const_iterator it;
for(it = g.adj(v).begin(); it != g.adj(v).end(); ++it){
int w = *it;
if( !marked[w] ){
marked[w] = true;
distTo[w] = distTo[v] + 1;
edgeTo[w] = v;
q.push(w);
}
}
//deque
q.pop();
}
}
/* @brief depth first search to detect cycle
*
*/
void DirectedCycle::dfs(const Digraph &dg, int v){
marked[v] = true;
onStack[v] = true;
list<int>::const_iterator it;
for( it = (dg.adj(v)).begin(); it != dg.adj(v).end(); ++it){
//there exists a cycle
if( hasCycle() ){
return ;
}
if( !marked[*it] ){
edgeTo[*it] = v;
dfs(dg, *it);
}else{
//cycle detected
if( onStack[*it] ){
for(int u = v; u != *it; u = edgeTo[u] ){
cyc.push_front(u);
}
cyc.push_front(*it);
cyc.push_front(v);
}
}
}
//v has been searched
onStack[v] = false;
}
static void ILT_Helper( Digraph& dg, ILT_EdgeDataMap2& datas, ArcFilter& ef, NodeFilter& nf, EdgeArray& sortedAirEdges, IntMap& cmap )
{
// 记录用风地点的始末搜索得到的count
AcDbIntArray sAirs, tAirs;
double st = Timer::rdtscSeconds();
// 显示排序后，用风地点的顺序编号
//DisplayAirEdgeNum(sortedAirEdges, datas);
int len = sortedAirEdges.length();
acutPrintf( _T( "\n用风地点个数:%d" ), len );
for( int i = 0; i < len; i++ )
{
Digraph::Arc e = sortedAirEdges[i];
Digraph::Node u = dg.source( e );
Digraph::Node v = dg.target( e );
sAirs.append( CountInFlowNodes( dg, ef, nf, u, cmap ) );
tAirs.append( CountOutFlowNodes( dg, ef, nf, v, cmap ) );
//acutPrintf(_T("\n第%d个用风地点【始节点】=%d 【末节点】=%d"), i, sAirs[i], tAirs[i]);
}
/*for(Digraph::NodeIt n(dg); n!=INVALID; ++n)
{
if(nf[n] && imap[n]==0) imap[n] = 1;
}*/
double et = Timer::rdtscSeconds();
acutPrintf( _T( "\n第1次正反dfs查找耗费时间:%.5f" ), et - st );
// 显示分支的始末节点的cmap值(测试用)
//DisplayEdgeCMapValue(dg, sortedAirEdges, datas, cmap, sAirs, tAirs);
//assert(sAirs.length() == len);
//assert(tAirs.length() == len);
st = Timer::rdtscSeconds();
for( int i = len - 1; i >= 0; i-- )
{
Digraph::Arc e = sortedAirEdges[i];
Digraph::Node u = dg.source( e );
Digraph::Node v = dg.target( e );
MinusInFlowNodes( dg, ef, nf, u, cmap, sAirs[i] );
PlusOutFlowNodes( dg, ef, nf, v, cmap, tAirs[i] );
}
et = Timer::rdtscSeconds();
acutPrintf( _T( "\n第2次正反dfs查找耗费时间:%.5f" ), et - st );
/*
* 处理完之后，可能出现一些分支的始节点(或末节点)的cmap=0
* 而末节点(或始节点)的cmap不等于0
* 这些分支中可能有部分分支也可视为主要进回风之间的联络巷
*/
// 显示分支的始末节点的cmap值(测试用)
//DisplayEdgeCMapValue(dg, sortedAirEdges, datas, cmap, sAirs, tAirs);
}
static void PrintVN(Digraph& dg, EdgeIdMap& eid, NodeIdMap& nid, VNO_EdgeMap& ed, VNO_FanMap&fd, VNO_NodeMap& nd, double Q)
{
cout<<"初始总风量："<<Q<<endl;
cout<<setiosflags(ios::left)<<setw(12);
cout<<"ID\t分支(始节点,末节点)\t风阻\t调节风阻\t风量\t始节点压力\t末节点压力"<<endl;
for(Digraph::ArcIt e(dg); e!=INVALID; ++e)
{
int id = eid[e];
Digraph::Node u = dg.source(e);
Digraph::Node v = dg.target(e);
double r = ed[e]->r;
double q = ed[e]->q;
double delta_r = ed[e]->delta_r;
cout<<dg.id(e)<<"\t"<<"e("<<id<<")=("<<nid[u]<<","<<nid[v]<<")"<<"\t"
<<"r(e"<<id<<")="<<r<<"\t"
<<"d_r(e"<<id<<")="<<delta_r<<"\t"
<<"q(e"<<id<<")="<<q<<"\t"
<<"p(v"<<nid[u]<<")="<<nd[u]->p<<"\t"
<<"p(v"<<nid[v]<<")="<<nd[v]->p<<endl;
if(fd[e]!=0)
{
cout<<"\t-->分支e"<<id<<"上有风机\n"
<<fd[e]->a0<<" "
<<fd[e]->a1<<" "
<<fd[e]->a2<<" "
<<endl;
}
if(ed[e]->fq > 0)
{
cout<<"\t-->分支e"<<id<<"固定风量:"<<ed[e]->fq<<endl;
}
}
}
/* @brief construct a SCC with a graph and compute
* strongly connected component
* @param dg Digraph
*/
SCC::SCC(const Digraph &dg){
//initialize private menber
marked = vector<bool>(dg.V(),false);
__id = vector<int>(dg.V());
__count = 0;
for(int i=0; i<dg.V(); ++i){
__id[i] = i;
}
//dg's reverse graph
const Digraph rdg = dg.reverse();
//rdg's order
DFSOrder order(rdg);
//reverse order of dg's reverse graph
deque<int> reverseOrder = order.reverseOrder();
//depth first searh in reverseOrder
__count = 0;
int num = reverseOrder.size();
for(int i=0; i<num; ++i){
int v = reverseOrder[i];
if( !marked[v] ){
dfs(dg,v);
//search one strongly connected component
++__count;
}
}
}
void KosarajuSCC::dfs(Digraph& dg, int v) {
marked[v] = true;
id[v] = count;
for (int w = dg.first(v); w < dg.n(); w = dg.next(v, w)) {
if (!marked[w])
dfs(dg, w);
}
}
//====================Digraph====================//
Digraph::Digraph(const Digraph &G){
__V = G.V();
__adj = vector<list<int> >(G.V());
for(int v=0; v<G.V(); ++v){
for(list<int>::const_iterator it=G.__adj[v].begin();
it != G.__adj[v].end(); ++it){
addEdge(v,*it);
}
}
}
/* @brief depth first search a DG
*/
void DirectedDFS::dfs(const Digraph &dg, int v){
marked[v] = true;
list<int>::const_iterator it;
for(it = (dg.adj(v)).begin(); it != (dg.adj(v)).end(); ++it){
if( !marked[*it] ){
edgeTo[*it] = v;
dfs(dg,*it);
}
}
}
/* @brief compute bfs forest start from a vector of sources
* @param dg digraph
* @param sources sources
*/
BFSDirectedPaths::BFSDirectedPaths(const Digraph &dg, const vector<int> &sources){
//initialize
marked = vector<bool>(dg.V(), false);
distTo = vector<int>( dg.V() );
edgeTo = vector<int>( dg.V() );
for(int i=0; i<dg.V(); ++i){
distTo[i] = INT_MAX;
}
bfs(dg, sources);
}
DirectedDFS::DirectedDFS(const Digraph &dg, const std::vector<int> &sources){
marked = vector<bool>(dg.V(), false);
edgeTo = vector<int>(dg.V());
srcs = set<int>(sources.begin(), sources.end());
for(size_t i=0; i<sources.size(); ++i){
if( !marked[ sources[i] ] ){
dfs(dg, sources[i] );
}
}
}
DirectedCycle(const Digraph &graph) : marked(graph.arrSize()), edgeto(graph.arrSize()), on_stack(graph.arrSize())
{
for (size_t i = 0; i < graph.arrSize(); i++)
marked[i] = on_stack[i] = false;
for (size_t i = 0; i < graph.arrSize(); i++)
{
if (!marked[i])
dfs(graph, i);
}
}
/* @brief construct DFS
*/
DirectedDFS::DirectedDFS(const Digraph &dg, int s){
marked = vector<bool>(dg.V(), false);
edgeTo = vector<int>(dg.V());
srcs = set<int>();
srcs.insert(s);
for(unsigned i=0; i<edgeTo.size(); ++i){
edgeTo[i] = i;
}
dfs(dg,s);
}
DepthFirstOrder(const Digraph &graph) : marked(graph.arrSize())
{
for (size_t i = 0; i < marked.size(); i++)
marked[i] = false;
for (size_t i = 0; i < graph.arrSize(); i++)
{
if (!marked[i])
dfs(graph, i);
}
}
// 使用宽度优先搜索BFS计算最短距离
static void SortAirEdges( Digraph& dg, ArcFilter& ef, Digraph::Node s, Digraph::Node t, const EdgeArray& airEdges, EdgeArray& es )
{
AFGraph afg( dg, ef );
Bfs<AFGraph> aBfs( afg );
aBfs.run( s );
//if(!aDfs.reached(t)) return; // s->t不可达
typedef ReverseDigraph<AFGraph> RDigraph;
RDigraph rdg( afg );
Bfs<RDigraph> bBfs( rdg );
bBfs.run( t );
//if(!bDfs.reached(s)) return;
typedef std::vector<AirEdgeDist> AirEdgeArray;
AirEdgeArray aes;
int len = airEdges.length();
for( int i = 0; i < len; i++ )
{
Digraph::Arc e = airEdges[i];
Digraph::Node u = dg.source( e );
Digraph::Node v = dg.target( e );
AirEdgeDist aed;
aed.e = e;
if( aBfs.reached( u ) )
{
aed.sd = aBfs.dist( u );
}
else
{
acutPrintf( _T( "\n第%d个用风地点【始点】不可达" ), i );
}
if( bBfs.reached( v ) )
{
aed.td = bBfs.dist( v );
}
else
{
acutPrintf( _T( "\n第%d个用风地点【末点】不可达" ), i );
}
aes.push_back( aed );
}
// 降序排序
std::sort( aes.begin(), aes.end() );
for( AirEdgeArray::iterator itr = aes.begin(); itr != aes.end(); itr++ )
{
es.append( itr->e );
}
}
void toposort(Digraph& dg, int *pos, int *vert) {
// Compute a topological ordering of dg. On return, pos[u]
// is the position of vertex u in the ordering and vert[i]
// is the vertex in the i-th position in the ordering.
int i; vertex u,v; edge e;
UiList q(dg.n());
int *nin = new int[dg.n()+1];
// Let nin[u]=in-degree of u and put nodes u with nin[u]=0 on q
for (u = 1; u <= dg.n(); u++) {
nin[u] = 0;
for (e = dg.firstIn(u); e != 0; e=dg.nextIn(u,e)) {
nin[u]++;
}
if (nin[u] == 0) q.addLast(u);
}
i = 0;
while (!q.empty()) { // q contains nodes u with nin[u] == 0
u = q.first(); q.removeFirst(); pos[u] = ++i; vert[i] = u;
for (e = dg.firstOut(u); e != 0; e = dg.nextOut(u,e)) {
v = dg.head(e);
if ((--(nin[v])) == 0) q.addLast(v);
}
}
if (i < dg.n()) fatal("toposort: graph has cycle");
}
static void FindStation_Helper( Digraph& dg, Digraph::Arc e, EdgeArray& es, bool searchStart = true, bool searchEnd = true )
{
if( searchStart ) // 是否需要从分支的始节点搜索
{
FindStationFromNode( dg, dg.source( e ), es, true );
}
if( searchEnd ) // 是否需要从分支的末节点搜索
{
FindStationFromNode( dg, dg.target( e ), es, false );
}
}
/* @brief construct a Directed Cycle objec with Digraph
* composite design pattern
*/
DirectedCycle::DirectedCycle(const Digraph &dg){
marked = vector<bool>(dg.V(), false);
onStack = vector<bool>(dg.V(), false);
cyc = deque<int>();
edgeTo = vector<int>(dg.V());
for(int v=0; v < dg.V(); ++v){
if( !marked[v] ){
dfs(dg, v);
}
}
}
/* @brief constructor with a Digraph and a source s
* compute breadth first search tree(forest) from s
* @param dg digraph
* @param s source vertex
*/
BFSDirectedPaths::BFSDirectedPaths(const Digraph &dg, int s){
//initialize
marked = vector<bool>(dg.V(), false);
distTo = vector<int>( dg.V() );
edgeTo = vector<int>( dg.V() );
for(int i=0; i<dg.V(); ++i){
distTo[i] = INT_MAX;
}
//breadth first search
bfs(dg, s);
}
/* @brief depth first search to compute __id
*/
void SCC::dfs(const Digraph &dg, int v){
marked[v] = true;
__id[v] = __count;
list<int>::const_iterator it;
for( it = dg.adj(v).begin(); it != dg.adj(v).end(); ++it){
int w = *it;
if( !marked[w] ){
dfs(dg, w);
}
}
}
/* @brief depth first search
*/
void DFSOrder::dfs(const Digraph &dg, int v){
marked[v] = true;
__vertexCallOrder.push_back(v);
list<int>::const_iterator it;
for( it = dg.adj(v).begin(); it != dg.adj(v).end(); ++it){
int w = *it;
if( !marked[w] ){
dfs(dg,w);
}
}
__preOrder.push_back(v);
__reverseOrder.push_front(v);
}
/* @brief topological sort of a Digraph
* @param dg Digraph
*/
DFSOrder::DFSOrder(const Digraph &dg){
marked = vector<bool>(dg.V(), false);
__vertexCallOrder = deque<int>();
__preOrder = deque<int>();
__reverseOrder = deque<int>();
//depth first search
for(int v=0; v<dg.V(); ++v){
if( !marked[v] ){
dfs(dg,v);
}
}
}
DigraphL::DigraphL(Digraph& g){
V = g.getNumVertices();
edges = new List<HalfEdge *>*[V];
for (int i = 0; i < V; i++)
edges[i] = new List<HalfEdge *>();
for (int v = 0; v < V; v++) {
for (int w = 0; w < V; w++) {
long weight = g.getWeight(v, w);
if (weight != INF)
insertEdge(v, w, weight);
}
}
}
/**
* Test the generations of UDRT and GDRT
*/
TEST(DigraphTest, TransformedDigraph)
{
Digraph* digraph = DigraphExample::generateDigraph2();
digraph->calculate_period_gcd();
digraph->calculate_all_gcd();
digraph->prepare_rbf_calculation(false);
digraph->prepare_ibf_calculation(false);
if (output) {
digraph->unit_digraph->write_graphviz(cout);
digraph->gran_digraph->write_graphviz(cout);
}
}
/**
* We test the constructor function and algorithm of calculating strongly connected components of Digraph class.
* The digraph comes from Figure 22-9 of "Cormen et al: Introduction to
* agorithms", Chapter 22.5.
*/
TEST(DigraphTest, StronglyConnectedComponents)
{
Digraph* digraph = DigraphExample::generateDigraph1();
digraph->generate_strongly_connected_components();
vector<Digraph*> sccs = digraph->sccs;
EXPECT_EQ(sccs.size(),4);
if (output) {
for (vector<Digraph*>::iterator iter = sccs.begin(); iter != sccs.end(); iter++) {
(*iter)->write_graphviz(std::cout);
}
}
}
static void FindILTEdges( Digraph& dg, ILT_EdgeDataMap2& datas, IntMap& cmap, EdgeArray& edges )
{
for( Digraph::ArcIt e( dg ); e != INVALID; ++e )
{
if( datas[e]->et == ET_VIRTUAL ) continue;
Digraph::Node u = dg.source( e );
Digraph::Node v = dg.target( e );
// 排除直接相连的分支
// 联络巷分支的始节点出度必须大于1，末节点的入度必须大于1
if( countOutArcs( dg, u ) <= 1 || countInArcs( dg, v ) <= 1 ) continue;
if( cmap[u]*cmap[v] < 0 ) edges.append( e );
}
}
Digraph* reverseGraph()
{
Digraph *R = new Digraph(V);
for (GraphIteratorTy I = begin(), E = end(); I != E; ++I) {
BasicBlock *A = I->first;
std::vector<BasicBlock *> B = I->second;
for (AdjIteratorTy II = B.begin(), EE = B.end(); II != EE; ++I) {
R->addEdge(*II, A);
}
}
return R;
}
