HDOJ 1384 差分约束

结题报告合集请戳：http://972169909-qq-com.iteye.com/blog/1185527

  1 /*题意：求符合题意的最小集合的元素个数

  2 题目要求的是求的最短路，

  3 则对于 不等式  f(b)-f(a)>=c,建立 一条 b 到 a 的边 权值为 c,则求的最长路 即为 最小值(集合)

  4 并且有隐含条件：0<=f(a)-f(a-1)<=1  则有边权关系(a,a-1,0)以及(a-1,a,-1);

  5 将源点到各点的距离初始化为INF(无穷大)，其中之1为0，最终求出的最短路满足 它们与该点之间相互差值最大

  6 差分约束

  7 　在实际的应用中，一般使用SPFA(Shortest Path Fast Algorithm)算法来实现。

  8 　　差分约束系统中源点到每个点的距离确定

  9 　　关于Dist[]的初始化化

 10 　　1.如果将源点到各点的距离初始化为0，最终求出的最短路满足 它们之间相互最接近了

 11 　　2.如果将源点到各点的距离初始化为INF(无穷大)，其中之1为0，最终求出的最短路满足 它们与该点之间相互差值最大。

 12 　　3.差分约束系统的确立要根据自己确定的约束条件，从约束点走向被约束点

 13 　　连边一般有两种方法，第一种是连边后求最长路的方法，第二种是连边后求最短路的方法。

 14 　　例：d[x]-d[y]>=Z

 15 　　如果想连边后求最长路 那么将不等式变形为这种形式 d[x]>=d[y]+z y---x连一条权值为z的边

 16 　　求最短路则变形成d[y]<=d[x]-z x---y连一条权值为-z的边。

 17 　　如果是别的不等式，也可以根据情况变形。但是要保证的是 两个变量（x,y)的系数一定要是正的。而常量则不一定。

 18 第一：

 19 感觉难点在于建图

 20 第二：

 21 ①：对于差分不等式，a - b <= c ，建一条 b 到 a 的权值为 c 的边，求的是最短路，得到的是最大值

 22 ②：对于不等式 a - b >= c ，建一条 b 到 a 的权值为 c 的边，求的是最长路，得到的是最小值

 23 ③：存在负环的话是无解

 24 ④：求不出最短路（dist[ ]没有得到更新）的话是任意解

 25 第三：

 26 一种建图方法：

 27 设x[i]是第i位置（或时刻）的值（跟所求值的属性一样），那么把x[i]看成数列，前n项和为s[n]，则x[i] = s[i] - s[i-1]；

 28 那么这样就可以最起码建立起类似这样的一个关系：0 <= s[i] - s[i-1] <= 1;

 29 其他关系就要去题目探索了

 30 */

 31 

 32 #include<iostream>

 33 #include<algorithm>

 34 #include<cstdio>

 35 #include<queue>

 36 #include<memory.h>

 37 using namespace std;

 38 const int MAXSIZE=50002;

 39 const int INF=0x3fffff;

 40 int dis[MAXSIZE],mmin,mmax,n,cnt,head[MAXSIZE],vis[MAXSIZE];

 41 struct node{

 42     int u,v,val,next;

 43 } Edge[MAXSIZE<<2];

 44 void addEdge(int u,int v,int val){

 45     Edge[cnt].u=u;

 46     Edge[cnt].v=v;

 47     Edge[cnt].val=val;

 48     Edge[cnt].next=head[u];

 49     head[u]=cnt++;

 50 }

 51 int spfa(int src,int ter){

 52     for(int i=src;i<=ter;i++) dis[i]=-INF;

 53     deque<int>q;

 54     q.push_back(src);

 55     vis[src] = 1;//标记当前顶点是否在队列中

 56     dis[src] = 0;

 57     while(!q.empty()){

 58         int u = q.front();

 59         q.pop_front();

 60         vis[u] = 0;

 61         for(int i = head[u];i != -1;i = Edge[i].next){

 62             int v = Edge[i].v;

 63             if(dis[v] < dis[u] + Edge[i].val){//松弛

 64                 dis[v] = dis[u] + Edge[i].val;

 65                 if(!vis[v]){

 66                     vis[v] = 1;

 67                     if(!q.empty()&&dis[v]<dis[q.front()])//SLF优化

 68                         q.push_front(v);

 69                     else q.push_back(v);

 70                 }

 71             }

 72         }

 73     }

 74     return dis[ter];

 75 }

 76 void SPFA(){

 77     for(int i=mmin;i<=mmax;i++) dis[i]=-INF;

 78     queue<int>q;

 79     q.push(mmin);

 80     vis[mmin]=1;

 81     dis[mmin]=0;

 82     while(!q.empty()){

 83         int u=q.front();

 84         q.pop();

 85         vis[u]=0;

 86         for(int i=head[u]; i!=-1; i=Edge[i].next){

 87             int v=Edge[i].v;

 88             if(dis[v]<dis[u]+Edge[i].val){

 89                 dis[v]=dis[u]+Edge[i].val;

 90                 if(!vis[v])

 91                 {

 92                     vis[v]=1;

 93                     q.push(v);

 94                 }

 95             }

 96         }

 97     }

 98     printf("%d\n",dis[mmax]);

 99 }

100 int main(){

101     int a,b,c,i,j;

102     while(scanf("%d",&n)!=EOF){

103         memset(head,-1,sizeof(head));

104         memset(vis,0,sizeof(vis));

105         cnt=0;

106         mmin = MAXSIZE;

107         mmax = 0;

108         for(i=1; i<=n; i++){

109             scanf("%d%d%d",&a,&b,&c);

110             b++;

111             if(mmin>a)  mmin=a;

112             if(mmax<b)  mmax=b;

113             addEdge(a,b,c);

114         }

115         for(i=mmin; i<mmax; i++){

116             addEdge(i+1,i,-1);

117             addEdge(i,i+1,0);

118         }

119         //spfa();

120         printf("%d\n",spfa(mmin,mmax));

121     }

122     return 0;

123 }

//双向队列 deque

//by MoreWindows http://blog.csdn.net/morewindows

#include <deque>

#include <cstdio>

#include <algorithm>

using namespace std;

int main()

{

    deque<int> ideq(20); //Create a deque ideq with 20 elements of default value 0

    deque<int>::iterator pos;

    int i;



    //使用assign()赋值  assign在计算机中就是赋值的意思

    for (i = 0; i < 20; ++i)

        ideq[i] = i;

    

    //输出deque

    printf("输出deque中数据:\n");

    for (i = 0; i < 20; ++i)

        printf("%d ", ideq[i]);

    putchar('\n');



    //在头尾加入新数据

    printf("\n在头尾加入新数据...\n");

    ideq.push_back(100);

    ideq.push_front(i);



    //输出deque

    printf("\n输出deque中数据:\n");

    for (pos = ideq.begin(); pos != ideq.end(); pos++)

        printf("%d ", *pos);

    putchar('\n');



    //查找

    const int FINDNUMBER = 19;

    printf("\n查找%d\n", FINDNUMBER);

    pos = find(ideq.begin(), ideq.end(), FINDNUMBER);

    if (pos != ideq.end())

        printf("find %d success\n", *pos);

    else

        printf("find failed\n");



    //在头尾删除数据

    printf("\n在头尾删除数据...\n");

    ideq.pop_back();

    ideq.pop_front();



    //输出deque

    printf("\n输出deque中数据:\n");

    for (pos = ideq.begin(); pos != ideq.end(); pos++)

        printf("%d ", *pos);

    putchar('\n');

    return 0;

}