最短路径之差分约束

Posted waaaafool

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了最短路径之差分约束相关的知识,希望对你有一定的参考价值。












一、前言

本文的目的是探讨最短路径与差分约束之间的关系。为了方便理解,本文将从存储图的数据结构,最短路径的算法,以及最短路径算法和差分约束之间的相互转换关系来讨论。而基于最短路径的有一个著名的三角形不等式,即两边之和大于第三边或者两边只差小于第三边,a+b>c和a-b<c。

  1. 图的存储结构

    工欲善其事必先利其器,为了更好的理解最短路径,必须先了解存储图的数据结构。

    一般而言,图的存储方式,有按节点存储按边存储两种方式。
  • 传统来说,按节点存储的是临接矩阵存储方式,优点是实现简单,一个二维数组就能实现。但缺点也很明显,需要O(n^2)的存储空间。
/*
*a[i][j]代表的是以i为起点j为终点的边的权值。
*一般而言的初始化是先让要初始化的每个节点都为无穷大。然后再输入。
*/
int a[N][N];
  • 可是在大部分情况下,我们的边数远远没有打到O(n^2),这种情况下,我们可以选择按边存储。按边存储的主要存储方式是邻接表,前向星,以及链式前向星。
/*
*邻接表是为每个节点建立好边的关系,将与每一个定点连接的边连成一个链表。
*在C++中,有为我们封装好的list链表,可以直接使用。
*
*/
list<int> li[N];

/*
*前向星也是按边存储,通过构造结构体节点,存储每一条边的开始节点,终止节点,和边权值。
*再将所有节点数组按照开始节点的大小进行排序,就可以达到连续访问从一起点出发的边。
*但同时缺点也明显,需要进行一次排序,开销也比较大。
*/
struct edge{
    int u,v,w;
    edge(){}
    edge(int _u,int _v,int _w){
        u=_u;
        v=_v;
        w=_w;
    }
}
edge eg[N];
bool cmp(edge a,edge b){
    return a.u<b.u;
}
sort(eg,eg+N,cmp);


/*
*链式前向星按照我的理解,就是以数组的方式构造链表。
*每条边的next都是指向上一条以相同节点开始的边。
*head[u]指向的总是以u开头的最后一条加入的边的地址。
*/
struct edge1{
    int u,v,w,next;
    edge(){}
    edge(int _u,int _v,int _w,int _next){
        u=_u;
        v=_v;
        w=_w;
        next=_next;
    }
}
edge eg[N];
void addedge(int u,int v,int w){
    eg[count]=edge1(u,v,w,head[u]);
    head[u]=count++;
}

/*
*其实根本不用这么复杂的结构,c++提供给了我们vector容器。
*/
vector<edge> eg[N];
eg[u].push_back(edge(u,v,w));
  1. 最短路径算法

    聊完了基本的数据结构,既然本文是介绍最短路径之差分约束,接下来就讲介绍最短路径的算法。最短路径的算法一般而言,是分为两种,一种是正权边,一种是存在负权边。
  • 正权边,使用的是dijkstra算法,为了优化,一般加入优先队列进行使用。
/*
*节点的数据结构
*id代表节点的编号,value代表源点到这点的当前最短距离
*/
struct node{
    int id;
    int value;
    node(){}
    node(int _id,int _value){
        id=_id;
        value=_value;
    }
    bool operator < (const node &a)const{
        return value>a.value;
    }
}
struct edge{
    int u,v,w;
    edge(){}
    edge(int _u,int _v,int _w){
        u=_u;
        v=_v;
        w=_w;
    }
}
vector<edge>eg[N];//存储边,利用vector实现链式前向星。
bool vis[N];//该节点是否已经属于扩展过的,是就是true,否就是false。
int pre[N],dist[N];//pre[i]存储到i的上一个节点,dist[i]存储源点到i的当前最短距离。
void dijkstra(int s){
   priority_queue<node> que;
   que.push(node(s,0);
   while(!que.empty()){
       node temp=que.front();
       int u=temp.id;
       que.pop();
       vis[u]=true;
       for(int i=0;i<eg[u).size;i++){
           int v=eg[u][i].v;
           int w=eg[u][i].w;
           if(!vis[v]&&dist[v]>dist[u]+w){
               dist[v]=dist[u]+w;
               pre[v]=u;
               que.push(node(v,dist[v]);
           }
       }
   }
}
void init(){
    for(int i=0;i<n;i++){
        vis[i]=false;
        dist[i]=INF;//INF表示为不可达
        eg[i].clear();
    }
}
  1. 而当图中存在负权边时,就需要使用,bellman-ford算法或者spfa算法,下面我们将介绍spfa算法,可以将其视作是bellman-ford算法的优化版本。
/*
*
*/
struct node{
    int id;
    int value;
    node(){}
    node(int _id,int _value){
        id=_id;
        value=_value;
    }
    bool operator < (const node &a)const{
        return value>a.value;
    }
}
struct edge{
    int u,v,w;
    edge(){}
    edge(int _u,int _v,int _w){
        u=_u;
        v=_v;
        w=_w;
    }
}
bool inq[N];//标记定点是否在队列中,true表示在,flase表示不在
vector<edge> eg[N];//用vector来模拟链式前向星,或者说邻接表
int dist[N],visitcount[N];//dist[i]记录从源点到i的当前最短距离,visitcount[i]表示i节点被访问的次数;
void spfa(int s,int n){
    for(int i=0;i<=n;i++){
        inq[i]=0;
        visitcount[i]=0;
    }
    priority_queue<node> que;
    que.push(node(s,0));
    inq[s]=1;
    while(!que.empty()){
        node temp=que.front();
        int u=temp.id;
        que.pop();
        inq[u]++;
        if(visitcount[u]>n){
            cout<<"No answer!"<<endl;
        }
        for(int i=0;i<eg[u].size();i++){
            int v=eg[u][i].v;
            int w=eg[u][i].w;
            if(dist[v]>dist[u]+w){
                dist[v]=dist[u]+w;
                if(!inq[v]){
                    que.push(node(v,dist[v]));
                    inq[v]=true;
                }
            }
        }
    }
}

二、差分约束

1.差分约束的定义

如若一个系统由n个变量和m个不等式组成,并且这m个不等式对应的系数矩阵中每一行有且仅有一个1和-1,其它的都为0,这样的系统称为差分约束( difference constraints )系统。

即可以化为:

x[i]-x[j]<=ak

x[c]-x[d]>=ak1

...

x[n]-x[p]<=akn

也就是说,差分约束,就是一组不等式的集合。同时我们观察,我们用来求最短路径的方程,dist[u]> dist[v]+w,通过移项,可以看到,和差分约束的方程相同,实际上,我们可以把x[i]-x[j]<=ak看作是,从节点j指向节点i的一条边为ak的有向图。于是通过多个不等式的集合,我们可以相应的建出有向图。例如下图:

技术图片

同时,我们可以从上面的介绍中看到x[i]-x[j]<=ak,x[i]-x[j]>=ak都是从i到j的一条边,边值是ak,但是有什么区别吗?

  • x[i]-x[j]<=ak,表示的是每一条边,都小于ak,所以我们可以看到,例如上图从0->3的路有三条,0->2->3 路径长度L1, 0->3路径长度L2,0->1->2->3路径长度L3三条路。
  • 所以实际上,不管我们怎么到达,都得满足全部约束,所以x[3]-x[0]<=min(L1,L2,L3)。也就是意味着,当我们在求从0到3的最短路径,就是在求满足约束情况下的最大值。
  • x[i]-x[j]>=ak,与上面相反,所得的实际结果应该是都大于每一条边,所求的x[3]-x[0]>=max(L1,L2,L3),所以求0到3的最长路径,就是求得在满足约束条件下的最小值。

以上是关于最短路径之差分约束的主要内容,如果未能解决你的问题,请参考以下文章

Layout POJ - 3169(差分约束+最短路)

(王道408考研数据结构)第六章图-第四节3:最短路径之BFS算法(思想代码演示答题规范)

差分约束系统

差分约束

(王道408考研数据结构)第六章图-第四节5:最短路径之弗洛伊德算法(思想代码演示答题规范)

[BZOJ2330][SCOI2011]糖果 差分约束系统+最短路