图结构实验

第1关：求图中边或弧的数目

#include "graph.h"  // 引用库函数文件  
namespace exa {     //请在命名空间内编写代码，否则后果自负
int solve(vector<vector<datagraph> > & G) {  
    int n = (int)G.size();  
    bool direct;  
    int ans = 0;  
    for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j) {  
        if (G[i][j].flag == true) {  
            direct = G[i][j].direct;  
            ++ans;  
        }  
    }  
    return direct == true ? ans : ans/2;  
}
}

第2关：无权图的最短路径

#include "graph.h"   // 引用库函数文件  
namespace exa {     //请在命名空间内编写代码，否则后果自负
vector<int> solve(vector<vector<datagraph> > & G, int u) {  
    int n = (int)G.size();  
    vector<int> dis(n,-1);  
    queue<int> q;  
    --u;  
    dis[u] = 0;  
    q.push(u);  
    while (!q.empty()) {  
        int v = q.front(); q.pop();  
        for (int i = 0; i < n; ++i) {  
            if (G[v][i].flag && dis[i] == -1) {  
                dis[i] = dis[v] + 1;  
                q.push(i);  
            }  
        }  
    }  
    return dis;  
}
}

第3关：判断有向树

#include "graph.h"   // 引用库函数文件  
namespace exa {     //请在命名空间内编写代码，否则后果自负
int f[105];
int find(int x) {return f[x] < 0 ? x : f[x] = find(f[x]);}  
void union_set(int x, int y) {  
    x = find(x);  
    y = find(y);  
    if (x != y) f[x] += f[y], f[y] = x;  
}
bool solve(vector<vector<datagraph> > & G) {  
    int n = G.size();  
    vector<int> vis(n,0);  
    for (int i = 0; i < n; ++i) f[i] = -1;  
    for (int i = 0; i < n; ++i) {  
        for (int j = 0; j < n; ++j) {  
            if (G[i][j].flag == true) {  
                ++vis[j];  
                union_set(i, j);  
            }  
        }  
    }  
    int zero = 0, one = 0;  
    for (int i = 0; i < n; ++i) {  
        if (vis[i] == 0) ++zero;  
        else if (vis[i] == 1) ++one;  
    }  
    return zero == 1 && one == n-1 && f[find(0)] == -n;  
}
}

第4关：深度优先生成树

#include "graph.h"   // 引用库函数文件  
namespace exa {     //请在命名空间内编写代码，否则后果自负
int vis[105];
void dfs(vector<vector<datagraph> > & G, int x, vector<int> & ans) {  
    if (vis[x] == 1) return ;  
    ans.push_back(x+1);  
    vis[x] = 1;  
    int n = (int)G.size();  
    for (int i = 0; i < n; ++i) if (G[x][i].flag == true) dfs(G, i, ans);  
}  
vector<int> solve(vector<vector<datagraph> > & G, int u) {  
    vector<int> ans;  
    --u;  
    dfs(G, u, ans);  
    return ans;  
}
}