# 图的邻接表和邻接矩阵表示以及相关算法

#include <iostream>
#include <climits>
#include <sstream>
#include <queue>
#include <string>
#include <stack>
#include <cstring>
#include <vector>
using namespace std;

const bool UNDIGRAPH = 0;

struct Graph{
string *vertexLabel;//the number of the labels is equal to vertexes
int vertexes;
int edges;
bool *visited;
int *distance;
int *path;
};

void buildGraph(Graph *&graph, int n) {
if (graph == NULL)
{
graph = new Graph();
graph->vertexes = n;
graph->edges = 0;
graph->vertexLabel = new string[n];
graph->visited = new bool[n];
graph->distance = new int[n];
graph->path = new int[n];
for (int i = 0; i < graph->vertexes; i++)
{
stringstream ss;
ss<<"v" << i+1;
ss >> graph->vertexLabel[i];
graph->visited[i] = false;
graph->distance[i] = INT_MAX;
graph->path[i] = -1;

if(UNDIGRAPH)
else
for (int j = 0; j < graph->vertexes; j++)
{
if(i == j)
else
}
}
}
}

void emptyGraph(Graph *graph) {
if (graph == nullptr) {
return;
}
delete []graph->vertexLabel;
delete []graph->visited;
delete []graph->distance;
delete []graph->path;
for (int i = 0;i < graph->vertexes;i++) {
}
delete graph;
}

void addEdge(Graph *graph, int v1, int v2, int weight) {
if (graph == nullptr) {
return;
}
if ((v1 < 0 || v1 > graph->vertexes) || (v2 < 0 || v2 > graph->vertexes)) {
return;
}
if (v1 == v2) {
return;
}
if (UNDIGRAPH) {
graph->edges++;
}
}
else {
graph->edges++;
}
}

void removeEdges(Graph *graph, int v1, int v2) {
if (graph == nullptr) {
return;
}
if ((v1 < 0 || v1 > graph->vertexes) || (v2 < 0 || v2 > graph->vertexes)) {
return;
}
if (v1 == v2) {
return;
}
if (UNDIGRAPH)
{
return;
graph->edges--;
}

else
{
return;
graph->edges--;
}
}

void clearVisit(Graph *graph) {
for (int i = 0;i < graph->vertexes;i++) {
graph->visited[i] = false;
}
}

void clearDistance(Graph *graph) {
for (int i = 0;i < graph->vertexes;i++) {
graph->distance[i] = INT_MAX;
}
}

void clearPath(Graph *graph) {
for (int i = 0;i < graph->vertexes;i++) {
graph->path[i] = -1;
}
}

int getIndegree(Graph *graph, int v) {
if (graph == NULL) {
return -1;
}
if (v < 0 || v > graph->vertexes) {
return -2;
}
if (UNDIGRAPH) {
return -3;
}
int degree = 0;
for (int i = 0;i < graph->vertexes;i++) {
degree++;
}
return degree;
}

int getOutdegree(Graph *graph, int v) {
if (graph == NULL) {
return -1;
}
if (v < 0 || v > graph->vertexes) {
return -2;
}
if (UNDIGRAPH) {
return -3;
}
int degree = 0;
for (int i = 0;i < graph->vertexes;i++) {
degree++;
}
return degree;
}

int getUndirectedDegree(Graph *graph, int v) {
if (graph == NULL) {
return -1;
}
if (v < 0 || v > graph->vertexes) {
return -2;
}
if(UNDIGRAPH)
{
int degree = 0;
for (int i = 0; i < graph->vertexes; i++)
{
degree++;
}
return degree;
}
else
return getIndegree(graph,v) + getOutdegree(graph,v);
}

//DFS递归的方式
void dfsR(Graph *graph, int i) {
if (!graph->visited[i]) {
cout << i << " has been visited" << endl;
graph->visited[i] = true;
}
for (int j = 0;j < graph->vertexes;j++) {
if (UNDIGRAPH) {
if (graph->AdjMat[i][j] != 0 && !graph->visited[j]) {
dfsR(graph, j);
}
}
else {
if (graph->AdjMat[i][j] != INT_MAX && !graph->visited[j])
dfsR(graph,j);
}
}
}

//dfs非递归
void dfsI(Graph *graph, int i) {
stack<int> st;
st.push(i);
while (!st.empty()) {
int top = st.top();
st.pop();
if (!graph->visited[top]) {
cout << top << " has been visited" << endl;
graph->visited[top] = true;
}
for (int j = 0;j < graph->vertexes;j++) {
if (UNDIGRAPH) {
if (graph->AdjMat[top][j] != 0 && !graph->visited[j]) {
st.push(j);
}
}
else {
if (graph->AdjMat[top][j] != INT_MAX && !graph->visited[j])
st.push(j);
}
}
}
}

void travelDFS(Graph *gra
ph) {
clearVisit(graph);
if(graph == NULL) return;
cout << "DFS\n";
for (int i = 0; i < graph->vertexes; i++)
graph->visited[i] = false;

for (int i = 0; i < graph->vertexes; i++)
dfsI(graph,i);
}

//bfs
void travelBFS(Graph *graph) {
if (graph == NULL) {
return;
}
clearVisit(graph);
cout << "BFS" << endl;
queue<int> qu;
for (int i = 0;i < graph->vertexes;i++) {
if (!graph->visited[i]) {
qu.push(i);
while (!qu.empty()) {
int top = qu.front();
qu.pop();
if (!graph->visited[top]) {
cout << top << " has been visited" << endl;
graph->visited[top] = true;
}
for(int j = 0;j < graph->vertexes;j++) {
if (UNDIGRAPH) {
if (graph->AdjMat[top][j] != 0 && !graph->visited[j]) {
qu.push(j);
}
}
else {
if (graph->AdjMat[top][j] != INT_MAX && !graph->visited[j])
qu.push(j);
}
}
}
}
}
}

//prim算法求一个图的最小生成树时间复杂度是O(n3)
void primOriginal(Graph *graph) {
if (graph == NULL) {
return;
}
clearVisit(graph);
int n = graph->vertexes;
bool *isin = new bool[n];
for (int i = 0;i < graph->vertexes;i++) {
isin[i] = false;
}
isin[0] = true;
vector<int> in;
in.push_back(0);
for (int i = 1;i < graph->vertexes;i++) {
int minWeight = INT_MAX;
int lastSt = -1;
int start = -1;
int nextIn = -1;
for(int j = 0;j < in.size();j++) {
start = in[j];
for (int k = 0;k < graph->vertexes;k++) {
if (UNDIGRAPH) {
if (graph->AdjMat[start][k] != 0 && !isin[k] && k != start) {
lastSt = start;
nextIn = k;
}
}
}
else {
if (graph->AdjMat[start][k] != INT_MAX && !isin[k] && k != start) {
lastSt = start;
nextIn = k;
}
}
}
}
}
if (nextIn == -1) {
cout << "can't find the MST" << endl;
return;
}
isin[nextIn] = true;
in.push_back(nextIn);
cout << lastSt << " to " << nextIn << " weight " << graph->AdjMat[lastSt][nextIn] << endl;
}
}

//利用distance和path将时间复杂度缩小到O(n2)
void primMin(Graph *graph) {
if (!graph) {
return;
}
clearVisit(graph);
graph->visited[0] = true;
graph->distance[0] = 0;
graph->path[0] = 0;
for (int i = 1;i < graph->vertexes;i++) {
graph->path[i] = 0;
}
for (int i = 1;i < graph->vertexes;i++) {
int minWeight = INT_MAX;
int nextIn = -1;
for (int j = 0;j < graph->vertexes;j++) {
if (!graph->visited[j] && graph->distance[j] < minWeight) {
minWeight = graph->distance[j];
nextIn = j;
}
}
if (nextIn == -1) {
cout << "prim algorithm end " << endl;
return;
}
cout << graph->path[nextIn] << " to " << nextIn << " weight " << graph->distance[nextIn] << endl;
graph->visited[nextIn] = true;
for (int j = 0;j < graph->vertexes;j++) {
if(!graph->visited[j] && graph->distance[j] > graph->AdjMat[nextIn][j]) {
graph->path[j] = nextIn;
}
}
}
}

//dijsktra算法
void dijsktra(Graph *graph, int v) {
if (graph == NULL) {
return;
}
clearVisit(graph);
clearDistance(graph);
clearPath(graph);
graph->visited[v] = true;
graph->distance[v] = 0;
int minNode = v;
int minDistance = INT_MAX;
for (int i = 0;i < graph->vertexes;i++) {
if (i == v) {
continue;
}
graph->path[i] = v;
}
cout << minNode << " has been visited distance : " << graph->distance[minNode] << " path node : " << graph->path[minNode] << endl;
while(true) {
minNode = -1;
minDistance = INT_MAX;
for(int i = 0;i < graph->vertexes;i++) {
if (!graph->visited[i] && graph->distance[i] < minDistance) {
minDistance = graph->distance[i];
minNode = i;
}
}
if (minNode == -1) {
cout << "dijsktra algorithm end" << endl;
break;
}
graph->visited[minNode] = true;
cout << minNode << " has been visited distance : " << graph->distance[minNode] << " path node : " << graph->path[minNode] << endl;
for (int i = 0;i < graph->vertexes;i++) {
if (!graph->visited[i] && graph->AdjMat[minNode][i] != INT_MAX && graph->distance[i] > graph->distance[minNode] + graph->AdjMat[minNode][i]) {
graph->path[i] = minNode;
}
}
}
}

//floyd算法,计算图中任意两个节点的最短距离
int **floyd(Graph *graph) {
if (!graph) {
return NULL;
}
int n = graph->vertexes;
int **res = new int *[n];
for (int i = 0;i < n;i++) {
res[i] = new int[n];
res[i][i] = 0;
}
for (int i = 0;i < n;i++) {
for (int j = 0;j < n;j++) {
}
}
for (int i = 0;i < n;i++) {
for (int j = 0;j < n;j++) {
if (i == j) {
continue;
}
for (int k = 0;k < n;k++) {
if(res[i][k] == INT_MAX || res[k][j] == INT_MAX) {
continue;
}
res[i][j] = min(res[i][j], res[i][k] + res[k][j]);
}
}
}
for (int i = 0;i < n;i++) {
for (int j = 0;j < n;j++) {
cout << res[i][j] << ' ';
}
cout << endl;
}
return res;
}

//拓扑排序可以扩展为检查一个图中是否有环
void topoSort(Graph *graph) {
if(UNDIGRAPH) return;
if(graph == NULL) return;
cout << "TopologicalSort"<<"\n";
int counter = 0;
queue <int> qVertex;
for (int i = 0; i < graph->vertexes; i++)
{
if(getIndegree(graph,i) == 0)
qVertex.push(i);
}
while (!qVertex.empty())
{
int vertexNO = qVertex.front();
counter++;

cout << graph->vertexLabel[vertexNO];
if(counter != graph->vertexes)
cout << " > ";
qVertex.pop();
for (int i = 0; i < graph->vertexes; i++)
{
if(i == vertexNO)
continue;

if (getIndegree(graph,i) != 0)
{
if(getIndegree(graph,i) == 0)
qVertex.push(i);
}
}
}
cout << "\n";
}

int main() {
Graph *graph = NULL;
buildGraph(graph,7);
//travelDFS(graph);
//travelBFS(graph);
//prim(graph);
//primMin(graph);
//dijsktra(graph, 0);
//floyd(graph);
//topoSort(graph);
}

#include <iostream>
#include <climits>
#include <sstream>
#include <queue>
#include <string>
#include <stack>
using namespace std;

struct edgeNode{
int vtxNQ;
int weight;
edgeNode *next;
};

struct vNode{
string vertexLabel;
edgeNode *first;
bool visited;
int distance;
int path;
int indegree;
};

struct Graph{
vNode *vertexList;
int vertexes;
int edges;
};

void buildGraph(Graph *&graph, int n) {
if (graph == NULL) {
graph = new Graph();
graph->vertexList = new vNode[n];
graph->vertexes = n;
graph->edges = 0;
for (int i = 0;i < n;i++) {
stringstream ss;
ss<<"v" << i+1;
ss >> graph->vertexList[i].vertexLabel;
graph->vertexList[i].path = -1;
graph->vertexList[i].visited = false;
graph->vertexList[i].first = NULL;
graph->vertexList[i].indegree = 0;
}
}
}

void makeEmpty(Graph *graph) {
if(graph == NULL) {
return;
}
for (int i = 0;i < graph->vertexes;i++) {
edgeNode *pEdge = graph->vertexList[i].first;
while (pEdge) {
edgeNode *tmp = pEdge;
pEdge = pEdge->next;
delete tmp;
}
}
delete graph;
}

void addEdge(Graph *graph, int v1, int v2, int weight) {
if (graph == NULL) return;
if (v1 < 0 || v1 > graph->vertexes-1) return;
if (v2 < 0 || v2 > graph->vertexes-1) return;
if (v1 == v2) return;
edgeNode *p = graph->vertexList[v1].first;
if(p == NULL) {
graph->vertexList[v1].first = new edgeNode;
graph->vertexList[v1].first->next = NULL;
graph->vertexList[v1].first->vtxNQ = v2;
graph->vertexList[v1].first->weight = weight;
graph->edges++;
graph->vertexList[v2].indegree++;
return;
}
while (p->next) {
if (p->vtxNQ == v2) {
return;
}
p = p->next;
}
if ( p->vtxNQ == v2) {
return;
}
edgeNode *node = new edgeNode();
node->next = NULL;
node->vtxNQ = v2;
node->weight = weight;
p->next = node;

graph->edges++;
graph->vertexList[v2].indegree++;
}

void removeEdge(Graph *graph, int v1, int v2) {
if (graph == NULL) return;
if (v1 < 0 || v1 > graph->vertexes-1) return;
if (v2 < 0 || v2 > graph->vertexes-1) return;
if (v1 == v2) return;
edgeNode *p = graph->vertexList[v1].first;
if(p == NULL) {
return;
}
if(p->vtxNQ == v2) {
edgeNode *q = p->next;
graph->vertexList[v1].first = q;
delete p;
graph->edges--;
graph->vertexList[v2].indegree--;
return;
}
edgeNode *q = NULL;
while(p->vtxNQ != v2) {
q = p;
p = p->next;
}
q->next = p->next;
p->next = NULL;
delete p;
graph->edges--;
graph->vertexList[v2].indegree--;;
}

//DFS遍历
void dfs(Graph *graph, int v) {
if (!graph->vertexList[v].visited) {
graph->vertexList[v].visited = true;
cout << v << " has been visited" << endl;
}
edgeNode *p = graph->vertexList[v].first;
while(p != NULL) {
if(!(graph->vertexList[p->vtxNQ].visited)) {
dfs(graph, p->vtxNQ);
}
p = p->next;
}
}

void dfsIter(Graph *graph, int v) {
if (!graph) {
return;
}
stack<int> nodes;
nodes.push(v);
while(!nodes.empty()) {
int top = nodes.top();
nodes.pop();
if (!graph->vertexList[top].visited) {
graph->vertexList[top].visited = true;
cout << top << " has been visited" << endl;
}
edgeNode *p = graph->vertexList[top].first;
while(p != NULL) {
if (!graph->vertexList[p->vtxNQ].visited) {
nodes.push(p->vtxNQ);
}
p = p->next;
}
}
}

void criticalPath(Graph *graph) {
int i, j, k;
int n = graph->vertexes;
int m = graph->edges;
int *ee = new int[n];
int *le = new int[n];
int *e = new int[m];
int *l = new int[m];
edgeNode *p;
for(int i = 0;i < n;i++) {
ee[i] = 0;
}
for(int i = 0;i < n - 1;i++) {
p = graph->vertexList[i].first;
while (p != NULL) {
j = p->vtxNQ;
if (ee[j] < ee[i] + p->weight) {
ee[j] = ee[i] + p->weight;
}
p = p->next;
}
}
for(int i = 0;i < n;i++) {
le[i] = 0;
}
le[n - 1] = ee[n - 1];
for(int i = n - 2;i >= 0;i--) {
p = graph->vertexList[i].first;
while(p != NULL) {
j = p->vtxNQ;
if (le[i] > le[j] - p->weight) {
le[i] = le[j] - p->weight;
}
p = p->next;
}
}
k = -1;
for(int i = 0;i < n - 1;i++) {
p = graph->vertexList[i].first;
while(p != NULL) {
j = p->vtxNQ;
e[++k] = ee[i];
l[k] = le[j] - p->weight;
if(l[k] == e[k]) {
cout << i << " "<<j << " " << p->weight << endl;
}
p = p->next;
}
}
}

void beginDFS(Graph* graph) {
if (!graph) {
return;
}
cout << "dfs\n";
for(int i = 0;i < graph->vertexes;i++) {
graph->vertexList[i].visited = false;
}
for(int i = 0;i < graph->vertexes;i++) {
dfsIter(graph, i);
}
}

int main() {
Graph *graph = NULL;
buildGraph(graph,7);
}