在此之前需要先学会基本数据结构，递归以及搜索、回溯
用了半个月的时间终于搞完了全部的基础图论。。。仅介绍到差分约束
图的定义自己百度= =这里直接开始说图的存储。
图的存储有N种写法，我所知道的有邻接矩阵、边表、邻接表、前向星、边集数组、十字链表、邻接多重表，这里只讨论较容易实现的3种也是最为普遍的3种：邻接矩阵，边表和邻接表。
先说说邻接矩阵吧。
邻接矩阵是一种图的直接的储存方式，对于稠密图来说，邻接矩阵的效率要高于邻接表以及边表，但是如其名，我们需要一个n*n的二维数组，所以其空间复杂度是很大的（相对于稀疏图中的邻接表和边表），因此我们仅在某些情况下使用邻接矩阵。如：Floyed（本身时间复杂度就是n*n*n），Dijkstra（堆优化则需要用邻接表），Prim（同Dijkstra），Topsort（可用邻接表写法），这些在之后的算法中会具体讲到。邻接矩阵大概是最简单的存储图的方式了，对于a[i][j](i,j∈V)来说，其代表的就是点i与点j之间的连通性，当然，a[i][j]的值本身也可代表i与j之间的边的权值（需要注意的是邻接矩阵是无法存重边的，因此对于某些题来说对于重边需要特殊处理）;
然后是边表。边表也是一种直接的储存方式，但其只是单纯地储存边的信息，无法像邻接表和邻接矩阵一样能够很快地遍历整张图，但是Kruskal和Bellman-Ford中需要用到边表，我们会在最小生成树中提到该算法。其储存方法如下（在此只介绍结构体的储存方法，其实还可以用vector来储存）：
1 struct edge{
2 int x,y,v;
3 }edge[MAX+10];//x为始端，y为末端，v为权值
之后是邻接表。邻接表在稀疏图中是一种比较高效的储存方法，因为它仅仅储存边，而不是将所有点与点之间的关系用二维数组来表示，因此在稀疏图中的效率要高于邻接矩阵。但邻接表与边表又有不同，邻接表采用的是链表的形式，表中不存起始点，仅仅存储终点，权值以及一个指针，该指针指向的是以相同的点为起点的下一条边的位置（下一条边指的是在这条边之前读入的边），同时我们还需要一个head数组，表示以每个点为起点的从后往前的第一条边的位置，和边表一样，这里只介绍结构体的储存方法，不介绍vector的储存。
1 struct edge{
2 int y,v,ne;
3 }edge[MAX+10];//y为边的末端，v为权值，ne为以当前边为起点记录的下一条边的位置
4 int head[MAX+10],len=0;//head[i]指向以i为起点的第一条边，len为邻接表的总长度
5 void addedge(int x,int y,int v)//加入一条以x为起点，终点为y的边，类似链表的操作
6 {
7 edge[++len].v=v;
8 edge[len].ne=head[x];
9 edge[len].y=y;
10 head[x]=len;
11 }
12
13 void init()//读入
14 {
15 memset(head,0,sizeof(head));
16 scanf("%d%d",&n,&m);
17 int x,y,v
18 for (int i=1;i<=n;i++)
19 {
20 scanf("%d%d%d",&x,&y,&v);
21 addedge(x,y,v);
22 addedge(y,x,v);//无向图
23 }
24 }
现在我们知道图的存储了，那么我们应该如何遍历这个图呢？
同搜索一样，我们可以采用DFS和BFS的方法对图进行遍历，DFS是以深度为优先进行搜索的，而BFS是以广度为优先进行搜索的。对于DFS来说，我们从一个点开始遍历，当出现连通时，我们就从下一个点开始继续遍历，因此DFS是“一条道走到黑”的，由于其用的是递归的方法进行搜索的，所以我们可以对遍历到的点进行回溯（在判断欧拉回路的时候需要使用）。而BFS就不一样了。它采用的是用队列的方式进行存储，以队列的头元素为起点，将其直接连向的，且没有被访问过的点全部加入到数组中。 这两种算法的效率大概是相同的，但需要注意的是如果不用栈进行模拟DFS的话，在递归层数较多的情况下是会爆栈的，BFS则不会。 还有一点：DFS可以进行回溯，而BFS则不能。
下面给出DFS和BFS的模板
1 //遍历——邻接矩阵DFS(数据较小时使用,较大时需用栈模拟)
2 void dfs(int p)
3 {
4 for (int i=1;i<=n;i++)
5 if (a[p][i]&&!f[i])
6 {
7 f[i]=false;
8 dfs(i);
9 f[i]=true;//根据情况加上回溯
10 }
11 }
12
13 //遍历——邻接表DFS
14 void dfs(int p)
15 {
16 for (int i=head[p];i;i=edge[i].ne)
17 if (!f[edge[i].y])
18 {
19 f[edge[i].y]=true;
20 dfs(edge[i].y);
21 f[edge[i].y]=false;//根据情况加上回溯
22 }
23 }
24
25 //遍历——邻接矩阵BFS
26 int queue[MAX+10];
27 void bfs(int p)
28 {
29 int h=0;tail=1;
30 queue[1]=p; f[p]=true;
31 while (h<tail)
32 {
33 i=queue[++h];
34 for (int j=1;i<=n;j++)
35 if (a[i][j]&&!f[j])
36 {
37 f[j]=true;
38 queue[++tail]=j;
39 }
40 }
41 }
42
43 //遍历——邻接表BFS
44 void bfs(int p)
45 {
46 int h=0;tail=1;
47 queue[1]=p; f[p]=true;
48 while (h++<tail)
49 for (int i=head[queue[h]];i;i=edge[i].ne)//将以当前起点为起点的所有边的终点加入到队列中
50 if (!f[edge[i].y])
51 {
52 f[edge[i].y]=true;
53 queue[++tail]=edge[i].y;
54 }
55 }
接下来是最短路问题。
稍有常识的OIer都会知道，一个三角形的任意两边之和是大于第三边的，但对于图来说并非不会出现两遍之和小于第三边的情况。这既是最短路的来源。因为不遵循三角形的性质，所以需要我们对i到j的边进行判断，如果说以k为中间点，i->k->j的耗费要大于i->j，那么我们需要对i到j的边进行更新，这就是图论中代码实现最简单的代码——Floyd的思路。代码如下：
1 void floyd()
2 {
3 for (int i=1;i<=n;i++)
4 a[i][i]=0;//如果没有负边的话需要将i到i的权值初始化为1
5 for (int k=1;k<=n;k++)
6 for (int i=1;i<=n;i++)
7 for (int j=1;j<=n;j++)
8 if (a[i][k]+a[k][j]<a[i][j])
9 a[i][j]=a[i][k]+a[k][j];
10 }
需要注意的是k是放在最外层的，而且k作为中间点时只能放在最外层。想一想为什么？这里我们采用反证法：
如果将i，j放在外层的话，i，j关于中间点k会进行更新，这样的话最终得到的i,j之间的最短路，我们实际上只更新了一遍，显而易见用这样的方法所找到的最短路不一定是最短的。
那么将k放在外层呢？ 基于每个点i,j来说，都会关于其他的所有点更新一次，这样我们就将这个点更新了n次，所求得的点一定是最大值。
这样的话Floyd其实采用的是动态规划的思想，k所代表的是当前的状态，不能将其放入内层。
（PS：Floyd求得的是全源最短路，且允许出现负权路）
Floyd的三层循环注定会耗费很长的时间，其复杂度为V*V*V，所以这需要我们找一个更加简便的方法。
如果说我每次询问i到j的最短路，那么是否需要将全源最短路求出来？事实上是不需要的，我们只需要基于源点对源点到其他点的最短路算出来就好了。仔细想想的话，我们需要以除了i之外的其它点作为中间点，将i到其它所有点的最短路更新n-1次即可。但策略并没有这么简单，我们是不是要按照点的顺序来求最短路？用贪心的思想来解的话，其实是必须找到当前i到其它点的最短距离，然后将这个最短距离作为中间点，对其它的点进行更新，我们称这样的算法为点i基于点j的一次松弛。这样的话当前已经松弛过的点一定是已经求出来最短路的点。这就是Dijkstra的思想。代码如下：
1 int d[MAX];//d为从源点到其他所有点的距离
2 bool vis[MAX];//记录某个点是否已经松弛过
3 void dijkstra(int s)
4 {
5 for (int i=1;i<=n;i++) dis[i]=a[s][i];
6 memset(vis,false,sizeof(vis));
7 for (int i=1;i<=n;i++)
8 {
9 int minn=MAX;
10 int k=0;
11 for (int j=1;j<=n;j++)
12 if (!vis[j]&&dis[j]<minn)
13 {
14 minn=dis[j];
15 k=j;
16 }
17 if (k==0) return;//找不到可松弛的点
18 vis[k]=false;
19 for (int j=1;j<=n;j++)
20 if (!vis[j]&&d[k]+a[k][j]<d[j])
21 d[j]=d[k]+a[k][j];
22 }
23 }
这样的算法，时间复杂度为V*V，如果要搜索全源最短路的话，其实效率是不如Floyd的。
另外想一下：是否有什么能够优化的算法？注意：我们每次找的都是最短的边。
我们学过一种数据结构，这种数据结构的顶端是所有数据中的最小/最大数据。没错就是堆，我们可以用堆，对Dijkstra进行优化，将所能枚举到的边放入小根堆中，每次取堆顶，如果这条边的末端的点还未被松弛，那么我们就关于这个点进行松弛。但是堆中只存储一个值的话显而易见是得不到边的具体信息的。
需要进行适当的拓展：C++的stl中内置了一种只含两个元素的结构体——pair，在没有进行重定义的情况下，会自动比较pair中的第一个元素，再比较第二个元素，这样的话我们可以定义一个pair量，其中存储的第一个元素是边的权值，第二个元素是边的下标，这样我们就可以进行Dijkstra了。代码如下：
1 #include<utility>
2 #include<queue>
3 typedef pair<int,int> pii;//第一个元素储存值，第二个元素储存下标
4 void dijkstra(int s)
5 {
6 priority_queue <pii,vector<pii>,greater<pii> > q;
7 memset(d,0x3f,sizeof(d));
8 d[s]=0;
9 memset(vis,false,sizeof(vis));
10 q.push(make_pair(d[s],s));
11 while (!q.empty())
12 {
13 pii tmp=q.top();
14 q.pop();
15 int x=tmp.second;
16 if (vis[x]) continue;
17 vis[x]=true;
18 for (int i=head[x];i;i=edge[x].ne)
19 if (d[edge[i].y]>d[x]+edge[i].v)
20 {
21 d[edge[i].y]=d[x]+edge[i].v;
22 q.push(make_pair(d[edge[i].y],edge[i].y));
23 }
24 }
25 }
注意要用邻接表。时间效率是V*logE，显然快了许多。（不用结构体的原因其实就是懒得重定义（逃））
但是Dijkstra是不能求带有负权路的最短路径的，因为当出现负权路时，已经松弛过的点还能继续进行松弛，而Dijkstra是基于每个点只松弛一次，所以求不出带负权边的最短路。
这时候我们还是只需要更新n次，每次基于所有边进行松弛，如果不能松弛则退出。这就是Bellman-Ford的思路。代码如下：
1 void bellmanford(int s)
2 {
3 memset(dis,0X3f,sizeof(dis));
4 dis[s]=0;
5 bool rel;
6 for (int i=1;i<=n;i++)
7 {
8 rel=false;
9 for (int j=1;j<=len;j++)
10 if (dis[edge[j].y]>dis[edge[j].x]+edge[j].v)
11 {
12 dis[edge[j].y]=dis[edge[j].x]+edge[j].v;
13 rel=true;
14 }
15 if (!rel) return;
16 }
17 }
需要注意的是Bellman-Ford使用的是边表，时间复杂度为V*E。
因为Bellman的特性，我们可以对其进行优化，我们用队列维护所有更新过的点，每次取队头的点进行更新，当更新到最短路时就将最短路的终点加入队列中（前提是这个点不在队列中），这就是SPFA的大致思路。代码如下：
1 int queue[MAX];
2 void spfa(int s)
3 {
4 int Head=0,tail=1;
5 memset(vis,false,sizeof(vis));
6 memset(dis,0x3f,sizeof(dis));
7 queue[1]=s; dis[s]=0; vis[s]=true;
8 while (Head<tail)
9 {
10 int tn=queue[++Head];
11 vis[tn]=false;
12 int te=head[tn];
13 for (int i=te;i;i=edge[i].ne)
14 {
15 int tmp=edge[i].y;
16 if (dis[tmp]>dis[tn]+edge[i].v)
17 {
18 dis[tmp]=dis[tn]+edge[i].v;
19 if (!vis[tmp])
20 {
21 vis[tmp]=true;
22 queue[++tail]=tmp;
23 }
24 }
25 }
26 }
27 }
注意：邻接表
我们可以发现，无论是哪种算法，都是严格按照三角形定律进行更新的，即：如果两边之和小于第三边，那么这两边之和就是起点到终点的新的最短路。
接下来是图的最小生成树问题。
所谓的生成树，就是通过点与点之间的关系，将某个点作为整个生成树的根，连接图中的所有点。最小生成树就是求生成树中用到的边权值的最小和。
需要注意的几点：1、我们求得的生成树连接了所有的点，因此图必须保证是连通的。2、已经连接到的点是否需要再次进行连接？我们可以运用树的特性来证明这一点：在一个树中，根节点没有父节点，除了根节点之外的所有点的父节点只有一个，因此不需要连接重复的点。这样的话我们就可以建立一个bool数组，记录每个点是否已经在最小生成树中。3、每次应该如何取边？同样是贪心的方法：我们用一个dis数组记录当前已经搜索到的能到达某个点的最短边，每次取出最短的边，然后将这个边的末端的点进行更新，即如果这个点能够连接到的边权值小于当前已知的最小边权值时，用这个边权值来替代它。这就是Prim算法的具体思想，代码实现和Dijkstra很相似，如下：
1 void prim(int s)
2 {
3 memset(dis,0x3f,sizeof(dis));
4 memset(vis,false,sizeof(vis));
5 for (int i=1;i<=n;i++) dis[i]=a[s][i];
6 vis[s]=true; sumn=0;//只有点s已做过松弛
7 for (int i=2;i<=n;i++)
8 {
9 int minn=MAX,c=0;
10 for (int j=1;j<=n;j++)//搜索能到达的最短的边
11 if (!vis[j]&&dis[j]<minn)
12 {
13 minn=dis[j];
14 c=j;
15 }
16 vis[c]=true;
17 sumn+=minn;
18 for (int j=1;j<=n;j++)//基于这个点进行松弛
19 if (a[c][j]<dis[j]&&!vis[j])
20 dis[j]=a[c][j];
21 }
22 }
注意这里使用了邻接矩阵，因此复杂度是V*V的。因为其思想与Dijkstra相似，所以同样也可以进行堆优化，堆优化的思路与Dijkstra的堆优化思路相似，这里不作证明，只给出代码：
1 typedef pair <int,int> pii;
2 void prim(int s)
3 {
4 priority_queue<pii,vector<pii>,greater<pii> > q;
5 memset(vis,false,sizeof(vis));
6 memset(dis,0,sizeof(dis));
7 vis[s]=true; sumn=0;
8 for (int i=head[s];i;i=edge[i].ne){
9 q.push(make_pair(edge[i].v,edge[i].y));
10 dis[edge[i].y]=edge[i].v;
11 }
12 for (int i=2;i<=n;i++){
13 pii a=q.top(); q.pop();
14 int minn=a.first,p=a.second;
15 while (vis[p]){
16 pii a=q.top(); q.pop();
17 minn=a.first,p=a.second;
18 }
19 vis[p]=true;
20 sumn+=minn;
21 for (int i=head[p];i;i=edge[i].ne)
22 if (!vis[edge[i].y]) q.push(make_pair(edge[i].v,edge[i].y));
23 }
24 }
这个代码未经证明，使用的时候需要注意一下。堆优化的Prim同样也是使用了邻接表，时间复杂度也是V*logE。
由Prim算法的证明我们可以得知每次取的都是最短的边，这样的话我们可以想到另外一种算法，既然取最短的边的话，我们可以使用边表，将边的权值按照从小到大进行排列，这样的话我们只需要一次遍历就能求出来最小生成树了，问题又来了：我们如何判断是否将当前边所连接的点已经在生成树中？同样根据树的特性我们可以采用并查集的方法将点进行合并，如果当前边所连接的点不在生成树中就将其加入生成树中，这就是Kruskal算法的大致思路，代码如下：
1 #include<algorithm>
2 struct edges{
3 int x,y,v;
4 }edge[MAX];
5 int father[x];
6 int getfather(int x)
7 {return (father[x]==x)? x:father[x]=getfather(father[x]);}
8
9 bool mycmp(edges x,edges y)
10 {return x.v<y.v;}
11
12 void kruskal()
13 {
14 for (int i=1;i<=n;i++) father[i]=i;
15 sort(edge+1,edge+1+len,mycmp);
16 int cnt=0;
17 for (int i=1;i<=len;i++){
18 int v=getfather(edge[i].x);
19 int u=getfather(edge[i].y);
20 if (v!=u){
21 father[v]=u;
22 if (++cal==n-1)
23 return;
24 }
25 }
26 }
我们可以发现这种算法的复杂度基本是由排序算法的复杂度决定的，我们使用了快排，因此复杂度为E*logE。
接下来是拓扑排序（Topsort），Topsort维护的是图中的先后顺序，因此当图中出现环的时候是无法求出拓扑序的。那么当图中没有环时应该如何进行拓扑排序？仔细想想，我们可以记录所有点的入度，然后将所有入度为0的点入队，每次枚举队头，将其能到达的点的入度减一，我们称这个操作为删边，当某个点的入度为0时就将其进入队列，这是BFS求拓扑序的思路，DFS思路和图的遍历的DFS方法是差不多的，注意删边。
仔细想想：我们根据BFS的算法思路可以得知一次BFS只能求出一种拓扑序，如果要求出所有的拓扑序的话，我们需要使用BFS，并在BFS上加入回溯即可。
Topsort算法代码如下：
1 //Topsort(邻接矩阵,队列,BFS)
2 void topsort()
3 {
4 int head=0,tail=0;
5 for (int i=1;i<=n;i++)//初始化队列，使队列中所有入度为0的点入队
6 if (id[i]==0) queue[++tail]=i;//id为i的入度
7 while (head<tail){
8 int i=queue[++head];
9 for (int j=1;j<=n;j++)
10 if (a[i][j]){
11 id[j]--;
12 if (id[j]==0) queue[++tail]=j;
13 }
14 }
15 }
16
17 //Topsort(邻接表,队列,BFS)
18 void topsort()
19 {
20 int Head=0,tail=0;
21 for (int i=1;i<=n;i++)
22 if (id[i]==0) queue[++tail]=i;
23 while (Head<tail){
24 int te=queue[++Head];
25 int tn=head[te];
26 for (;tn!=-1;tn=edge[tn].ne){
27 id[edge[tn].y]--;
28 if (id[edge[tn].y]==0) queue[++tail]=edge[tn].y;
29 }
30 }
31 }
32
33 //Topsort(邻接矩阵,DFS,可求出所有拓扑序)
34 void topsort(int i,int sum)//i为当前元素的位置，sum为队列中的元素个数
35 {
36 if (sum==n){
37 flag=true; return;
38 }
39 for (int j=1;j<=n;j++)
40 if (a[i][j])
41 id[j]--;
42 for (int j=1;j<=n;j++){
43 if (!used[j]&&id[j]==0){
44 used[j]=true;
45 q[sum+1]=j;//将点加入队列中
46 dfs(j,sum+1);
47 used[j]=false;
48 }
49 if (flag) return;//不加上则可求出所有的拓扑序，但需要特殊处理
50 }
51 for (int j=1;j<=n;j++)
52 if (a[i][j])
53 id[j]++;//回溯,可求出所有拓扑序
54 }
55
56 //Topsort(邻接表，DFS，可求出所有拓扑序)
57 void topsort(int i,int sum)
58 {
59 if (sum==n){
60 flag=true; return;
61 }
62 for (int j=head[i];j!=-1;j=edge[j].ne) id[edge[j].y]--;
63 for (int j=j;j<=n;j++){
64 if (id[j]==0&&!used[j]){
65 used[j]=true;
66 q[sum+1]=j;
67 dfs(j,sum+1);
68 used[j]=false;
69 }
70 if (flag) return;
71 }
72 for (int j=head[i];j!=-1;j=edge[j].ne) id[edge[j].y]++;
73 }
接下来是图的割边，割点以及强连通分量，因为在这里仅讨论Tarjan算法，所以我们将这三者同时进行讨论：
对于割点来说，我们可以用N次DFS来判断，每次删除一个点，然后判断图是否连通，这样的算法效率显然是极低的。我们知道DFS算法会形成一颗树，对于每一棵DFS树来说，其子节点不会通向任意一个根节点，我们称这个子节点到其之前的边为返祖边，那么如果我们要判断一个点是否为割点，在它形成的DFS树中，不会有任何一个点能够通向其根节点之前的点，根据这样的思路，我们可以建立一个dfn数组和一个low数组，dfn记录的是点当前的DFS层数，low记录点的最小的DFS层数，我们在DFS的同时对这两个数组进行更新，对于当前点i，如果其能够通向其之前的任意一个节点j，那么用dfn[j]来更新low[i]，如果这个节点的子节点j的low值小于low[i]，用low[j]来更新low[i]，并将更新后的low[i]与dfn[j]进行比较，如果dfn[j]>=low[i]，那么将i的子节点加一，这样我们判断割点的情况就很简单了，一个点是割点，如果这个点存在父节点，那么它的子节点的个数一定大于等于1，如果不存在父节点，那么它的子节点个数一定大于等于2，这样的点就是要求的割点。代码如下：
int dfn[MAX],low[MAX],ind=0;
void tarjan(int x,int par=0){
dfn[x]=low[x]=++ind;
son=0;
for (int i=head[x],y;i;i=edge[i].ne)
if ((y=edge[i].y)!=par){//防止访问父节点
if (!dfn[y]){
tarjan(y,x);
if (low[y]<low[x]) low[x]=low[y];//更新low[x]
if (low[y]>=dfn[x]) son++;//如果low[y]>dfn[x]，则此子树上没有返祖边
}
else if (dfn[y]<low[x]) low[x]=dfn[y];
}
if (son==2||(son==1&&par)) ans[++tot]=x;
}
割边的思路与割点相似，其父边需要用一个反向边的下标来注释，一条边是割边，当且仅当其起点的dfn值等于low值，证明思路与求割点相似。代码如下：
1 void tarjan(int x,int par=0){
2 dfn[x]=low[x]=++ind;
3 for (int i=head[x],y;i;i=edge[i].ne)
4 if (i!=par){
5 if (!dfn[y=edge[i].y]){
6 tarjan(y,rev[i]);//rev[i]为i的反向边
7 if (low[y]<low[x]) low[x]=low[y];
8 }
9 else if (dfn[y]<low[x]) low[x]=dfn[y];
10 }
11 if (low[x]==dfn[x]) ans[++tot]=par;
12 }
强连通分量与割边和割边不太相似，后两者是无向图，而强连通分量则是存在于有向图中的，它指的是无向图中的极大连通子图，我的理解就是无向图中的不被任何其他环所包括的环。如何判断环呢？其实很简单，我们只需要判断一个点i所连接的一个点j是否能够相互连通就好了，但是我们不能保证这个环不被其他环所包括，且无法确定某个点处于哪个强连通分量中。
为了解决这个问题，我们需要引入栈，将所有访问过的点压入栈中，然后和割边割点一样的方法对dfnlow进行更新，如果出现dfn[i]==low[i]时，将i之后能访问到的所有点弹出栈，并将其记录在同一个强连通分量中，这样的操作我们也称为缩点，代码如下：
1 int stack[MAX],top=0;
2 void tarjan(int x){
3 dfn[x]=low[x]=++ind;
4 vis[stack[++top]=x]=true;
5 for (int i=head[x],y;i;i=edge[i].ne){
6 if (!dfn[y=edge[i].y]){
7 tarjan(y);
8 if (low[y]<low[x]) low[x]=low[y];
9 }
10 else if (vis[y]&&dfn[y]<low[x]) low[x]=dfn[y];
11 }
12 if (dfn[x]==low[x]){
13 int k; tot++;
14 do{
15 k=stack[top--];
16 vis[k]=false;
17 bel[k]=tot;
18 }while (k!=x);
19 }
20 }
接下来是最后一环——差分约束系统。
差分约束系统只是一种建图的方法。
我们先来看一些不等式组:a>b; b=a; c>=a; b<c，我们可以将其转化为：b+1<=a; b+0<=a; a+0<=b; a+0<=c; b+1<=c;
对于这样的不等式组，我们可以想到SPFA中的松弛操作：
if (dis[tn]+edge[i].v<dis[tmp])
dis[tmp]=dis[tn]+edge[i].v;
那么我们就可以将这个不等式组转化为图的形式：
对于一个不等式组b+1<=a来说，我们可以将b看做一条边的起点，将a看做该边的终点，1为边权值，这样我们就可以建立条从b到a的有向边，这条边的边权值为1.
这就是差分约束的具体建图方法。
我们来列出对于所有不等式的建图方法：
1、a>b+n -> b+1+n<=a -> b到a有一条边权值为1+n的边
2、a>=b+n -> b+n<=a -> b到a有一条边权值为n的边
3、a==b+n -> a>=b+n&&a<=b+n -> b到a有一条边权值为0的双向边
4、a<=b+n -> a到b有一条边权值为-n的边
5、a<b+n -> a+1-n<=b -> a到b有一条边权值为1-n的边
建图的方法有了，那么我们如何求最小或最大的k值，使得对于任意一个点都有一个值v，使得0<=v<=k，并让图中的所有不等式都成立呢？都有边了直接SPFA不就好了嘛= =
当然方法不止SPFA。
如果当一个不等式中不存在2、3、4条件时，显而易见我们可以进行Topsort来求k值，这样的效率大概是快于SPFA的，代码如下：
1 bool spfa()
2 {
3 memset(dis,0,sizeof(dis));
4 int Head=0,tail=0;
5 for (int i=1;i<=n;i++)
6 if (id[i]==0) queue[++tail]=i;
7 while (Head<tail){
8 int tn=queue[++tail];
9 for (int i=head[tn],y;i;i=edge[i].ne){
10 id[y=edge[i].ne]--;
11 dis[y]=max(dis[y],dis[tn]+edge[i].v);
12 if (id[y]==0) queue[++tail]=y;
13 }
14 }
15 if (tail<n) return true;//如果访问的点的个数小于当前点的个数，返回真，否则返回假
16 return false;
17 }
3条件存在时我们需要将双向边改为单向边，据不完全测试，Topsort可以求出最小k值= =
注意在这些不等式组建立成的图中是可以出现环的，但无论是自环还是其它环（前提是这个环中存在一个边的边权值e[i].v!=0）都不能使这个不等式组成立，我们在Topsort中采用了删边，所以出现环的时候我们访问不到所有的边，这时候只需要将队列中元素的个数与点的个数比较就好，但是如果SPFA中出现了环了呢？
显然我们可以证明出现自环的情况下会做无限松弛，一个特判就好了。
于此同时我们一般上要建立一个超级源点s，这个源点到其它所有的点都存在边，我们只需要关于s做SPFA就好了，代码如下
bool spfa()
{
while (Head<tail){
int tn=queue[++Head];
for (int i=head[tn],y;i;i=edge[i].ne)
if (dis[y=edge[i].y]<dis[tn]+edge[i].v){
dis[y]=dis[tn]+edge[i].v;
if (dis[y]>n) return true;
if (!vis[y]){
vis[y]=true; queue[++tail]=y;
}
}
vis[tn]=false;
}
return false;
}
当然我们还可以采用另外一种方法：先将所有点入队后再开始做SPFA，实际上是和建立源点S一样的，但是这种方法莫名地比建立源点快= =所以对于查分约束系统来说我们可以直接采用这一种方法来求解
就这样吧。