图论基础

（以前的草稿，内容很少，删了也可惜，LCA、桥、割、联通分量、二分图之类的都没写了，因为懒。。。）

一.图的遍历：

1.前向星

名字虽然很奇怪，其实就是链表存储的图，当矩阵存不下或者花费时间较多的情况下使用。（基本没用过矩阵建图了。。。。）

也可以使用stl的vector，但是一般比较占内存和效率不够。贴上代码：

#include <iostream>
#include <cstdlib>
#include <cstdio>
using namespace std;
struct Node
{
    int to;
    int next;
};
struct Node edges[1000];
int head[100];
void AddNode(int from, int to,int k)
{
    edges[k].to=to;
    edges[k].next=head[from];
    head[from]=k;
}
int main()
{
    int node,edge;
    int i;
    int from,to;
    int count=0;
    scanf("%d%d",&node,&edge);
    for(i=0;i<edge;i++)
    {
        scanf("%d%d",&from,&to);
        AddNode(from,to,++count);
        AddNode(to,from,++count);
    }
    int nd;
    //for(int k=head[u];k!=-1;k=edges[k].next)我比较喜欢这种遍历
    for(i=1;i<=node;i++)
    {
        nd=head[i];
        while(nd!=0)
        {
            printf("(%d,%d) ",i,edges[nd].to);
            nd=edges[nd].next;
        }
        printf("\n");
    }
    return 0;
}

2.拓扑排序

 对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若<u，v> ∈E(G)，则u在线性序列中出现在v之前。

   通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。

   注意:

   1)只有有向无环图才存在拓扑序列;

   2)对于一个DAG,可能存在多个拓扑序列;

做法即不断从图中拿出没有入入度的点即可。

二.路径问题

1.最短路

（1）.dijkstra单源最短路，图中不能有负权 复杂度o(n^2)。如果有多条最短路并且要知道是哪些边，可以跑一边最短路之后从终点向前推。点击打开链接

memset(v, 0, sizeof(v));//矩阵存储
for(int i = 0; i < n; i++) d[i] = (i==0 ? 0 : INF);
for(int i = 0; i < n; i++) {
  int x, m = INF;
  for(int y = 0; y < n; y++) if(!v[y] && d[y]<=m) m = d[x=y];
  v[x] = 1;
  for(int y = 0; y < n; y++) d[y] = min(d[y], d[x] + w[x][y]);
}

const int INF=0x3f3f3f3f;
const int MAXN=1000010;
struct qnode
{
    int v;
    int c;
    qnode(int _v=0,int _c=0):v(_v),c(_c){}
    bool operator <(const qnode &r)const
    {
        return c>r.c;
    }
};
struct Edge
{
    int v,cost;
    Edge(int _v=0,int _cost=0):v(_v),cost(_cost){}
};
vector<Edge>E[MAXN];
bool vis[MAXN];
int dist[MAXN];
void Dijkstra(int n,int start)//点的编号从1开始
{
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;i++)dist[i]=INF;
    priority_queue<qnode>que;
    while(!que.empty())que.pop();
    dist[start]=0;
    que.push(qnode(start,0));
    qnode tmp;
    while(!que.empty())
    {
        tmp=que.top();
        que.pop();
        int u=tmp.v;
        if(vis[u])continue;
        vis[u]=true;
        for(int i=0;i<E[u].size();i++)
        {
            int v=E[tmp.v][i].v;
            int cost=E[u][i].cost;
            if(!vis[v]&&dist[v]>dist[u]+cost)
            {
                dist[v]=dist[u]+cost;
                que.push(qnode(v,dist[v]));
            }
        }
    }
}
void addedge(int u,int v,int w)
{
    E[u].push_back(Edge(v,w));
}

（2）.spfa，单源最短路，可以判负环。

bool spfa(int s)//若存在负环返回false
{
    queue<int> q;
    memset(inq,0,sizeof(inq));
    memset(cnt,0,sizeof(cnt));
    memset(d,0x3f3f3f3f,sizeof(d));
    d[s]=0;
    inq[s]=1;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        inq[u]=0;
        for(int i=head[u];i!=-1;i=edges[i].next)
        {
            int v=edges[i].to;
            int w=edges[i].w;
            if(d[v]>d[u]+w)//松弛操作
            {
                d[v]=d[u]+w;
                if(!inq[v])
                {
                    q.push(v);
                    inq[v]=1;
                    if(++cnt[v]>n)//最多松弛n-1次，所有有负环
                        return false;//有负环
                }
            }
        }
    }
    return true;
}

（3）. flody算法，求图中任意两点间的最短路o(n^3) 注意其实flody是可以存储路径的，贴一个hdu1385的代码，问从a到b的最短路并且字典序最小的输出，該题经过一个城市也会有花费，所以也要算入最短路。

#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 1234;
const int _max = 0x3f3f3f3f;
int dist[maxn][maxn];
int dir[maxn][maxn];
int a[maxn];
int n, k;

void flody()
{
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                if(dist[i][j] > dist[i][k] + dist[k][j] + a[k])
                {
                    dist[i][j] = dist[i][k] + dist[k][j] + a[k];
                    dir[i][j] = dir[i][k];
                }
                else if(dist[i][j] == dist[i][k]+dist[k][j]+a[k] && dir[i][j]>dir[i][k])
                    dir[i][j] = dir[i][k];
}

void outpath()
{
    int u, v;
    while(scanf("%d %d", &u, &v))
    {
        if(u==-1&&v==-1) break;
        int m = u;
        printf("From %d to %d :\n", u, v);
        printf("Path: %d", u);
        while(u!=v)
        {
            printf("-->%d", dir[u][v]);
            u = dir[u][v];
        }
        printf("\n");
        printf("Total cost : %d\n\n", dist[m][v]);
    }
}

int main()
{
    while(scanf("%d", &n) != EOF && n)
    {
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
            {
                scanf("%d", &dist[i][j]);
                if(dist[i][j] == -1) dist[i][j] = _max;
                dir[i][j] = j;
            }
        for(int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        flody();
        outpath();
    }
}

2..第k短路，求s到t的第k短路，先求一遍最短路，得到dist数组，再用当前已经走过的长度+dist[i]作为启发函数，A*搜索。A*搜索的过程中不判重，直到第k次到达终点则是k 短路。k短路题

3.欧拉路径和欧拉回路。注意图要联通！

欧拉路径：图中经过每条边一次且仅一次的路径 

欧拉回路：图中经过每条边一次且仅一次的路径并且回到原点。  欧拉路径学习

基于以上可以做这题，poj 2513，网络赛的题目：hdu 5883

但是有的时候题目会需要求一条欧拉回路的方案，我们需要知道欧拉回路的一个性质，如果从一个图G中去掉一个圈得到的新图G'也有欧拉回路，那么G也有欧拉回路，所以一旦找到一个圈就将这个圈从图里拿出来，反复如此直到图空为止。

poj 1041 John's trip 求字典序最小的欧拉回路序列

const int maxn=1995;
const int maxm=1000000;
int fa[maxn];
vector<pair<int,int> > adj[maxn];
bool vis[maxm];
int getfa(int x)
{
	return x==fa[x]?x:fa[x]=getfa(fa[x]);
}
void add(int x,int y,int z)
{
	adj[x].push_back(make_pair(z,y));
	adj[y].push_back(make_pair(z,x));
}
vector<int> path;
#define eid first
#define vtx second
void dfs(int u)
{
	for(int i=0;i<adj[u].size();++i)
		if(!vis[adj[u][i].eid])
		{
			vis[adj[u][i].eid]=true;
			dfs(adj[u][i].vtx);
			path.push_back(adj[u][i].eid);
		}
}
#undef eid
#undef vtx
bool solve(int n)
{
	for(int i=0;i<=n;i++)
		fa[i]=i;
	for(int i=1;i<=n;i++){
		for(int j=0;j<adj[i].size();j++){
			fa[getfa(i)]=getfa(adj[i][j].second);
		}
	}
	int origin=-1;
	for(int i=1;i<=n;i++)
		if(adj[i].size())
		{
			if(adj[i].size()%2) return false;
			if(origin==-1) origin=i;
			if(getfa(i)!=getfa(origin)) return false;
			sort(adj[i].begin(),adj[i].end());
		}
	path.clear();
	memset(vis,false,sizeof(vis));
	if(origin!=-1) dfs(origin);
	reverse(path.begin(),path.end());//倒置
	return true;
}