差分约束 链式前向星 （学习

    在学习差分约束的时候先学了下链式前向星存图，因为这存的方便，也优化了最短路算法，具体代码如下：

struct xxx
{
    int v,w;
    int next;
}edge[maxn];
int head[maxn];
int cnt=0;

void add(int u,int v,int w)
{
    edge[cnt].v=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}

    cnt 相当于每条路存的位置

    head[u] 表示以u为开头的最后一条路的存储位置

    .next 存的是上一条同样以u开头的路存的位置。

比如有两条路 ：

                        1->2==3   

                        1->3==4 

    那么edge[1].next=head[1]=0,head[1]=1。这样存可以轻松遍历出以任意u开头的所有路径：

/******head内初值为-1******/

    int t=u;
    for(int i=head[t]; i!=-1; i=edge[i].next)
    {
        
    }
    

    差分约束其实就是把有关系的不等式转换成最短路来求 

比如： A-B<=10

            B-C<=10

            求A-C最大为多少？

对于这种情况 我们可以将两个不等式转换为路径 即：B->A==10 , C->B==10 ，然后求出C->A的最短路径即为结果

再比如： A-B>=10

               B-C>=10

               求A-C最小为多少

那我们就可以建立：B->A==10 , C->B==10 ，但此时要求C->A 的最长路

可以得出个规律：求最大值， 不等式为 <= ，求最短路

                             求最小值，不等式为 >= ,   求最长路

若是不等式同时出现 <=和>=那我们只需按所需求的最大或最小把不等式方向改变再建立路径即可；

但差分约束一般麻烦在隐含条件，看例题 POJ - 1716

题目意思就是：给出n个区间，现在要你找出一个点集，使得这n个区间都至少有2个元素在这个点集里面，问这个点集最少有几个点。

第一行一个整数n。 接下来n行，每行两个整数a,b,表示区间的左端点和右端点，被空格隔开。

题目就这么多 ，那我们首先要发现的是 区间[a,b]内的点必定超过两个 那我们以区间内点的数量 D[ ]来建立不等式就是：

D[b+1]-D[a]>=2，但这一个不等式又显然不能得到最终结果，所以我们还要加上 0<=D[i+1]-D[i]<=1，再根据题意找最少的 那就是建路求最长路， 所以说差分约束烦就在要找隐含条件。附上代码：
 

#include<stdio.h>
#include<string>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
#define maxn  10005
#define LL long long
int inf=1000000007;

struct xxx
{
    int v,w;
    int next;
}edge[4*maxn];
int head[maxn];
int dis[maxn];
bool vis[maxn];
int cnt=0;
int mi=maxn,ma;

void add(int u,int v,int w)
{
    edge[cnt].v=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
void spfa()
{
    dis[mi]=0;
    queue<int> q;
    q.push(mi);
    vis[mi]=1;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        vis[t]=0;
        for(int i=head[t];i!=-1;i=edge[i].next)
        {
            int j=edge[i].v;
            if(dis[j]<dis[t]+edge[i].w)
            {
                dis[j]=dis[t]+edge[i].w;
                if(!vis[j])
                {
                    q.push(j);
                    vis[j]=1;
                }
            }
        }
    }
}

int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        mi=maxn;
        ma=0;
        cnt=0;
        memset(head,-1,sizeof(head));
        memset(edge,0,sizeof(edge));
        for(int i=0;i<n;i++)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            mi=min(a,mi);
            ma=max(b+1,ma);
            add(a,b+1,2);
        }
        for(int i=mi;i<=ma;i++){
            vis[i]=0;
            dis[i]=-inf;
        }
        for(int i=mi;i<ma;i++)
        {
            add(i,i+1,0);
            add(i+1,i,-1);
        }
        spfa();
        printf("%d\n",dis[ma]);
    }
    return 0;
}