Intervals--POJ 1201

1、题目类型：差分约束系统、SPFA算法。

2、解题思路：（1）根据输入输入构图，并非简单的对输入进行构图，根据差分约束系统的理解，每个结束节点+1,而且第 i 个节点到第 i+1 个节点的权值为0、第 i+1 个节点到第 i 个节点的权值为-1；（2）SPAF算法寻找最短路径，是该路径的权值最大，初始状态下为-inf。

3、注意事项：构图是解决差分约束系统这类题的关键，根据择优的不同，合适的选择SPFA的判断条件。

4、实现方法:

  
    

   
     
   
     #include
   
     <
   
     iostream
   
     >
   
     
#include
   
     <
   
     vector
   
     >
   
     
#include
   
     <
   
     algorithm
   
     >
   
     
#include
   
     <
   
     queue
   
     >
   
     

   
     using
   
      
   
     namespace
   
      std;

   
     #define
   
      inf -10000000
   
     


   
     struct
   
      Edge
{
 
   
     int
   
      v,c;
};

vector
   
     <
   
     Edge
   
     >
   
      head[
   
     50010
   
     ];

   
     int
   
      n,MaxP;

   
     int
   
      mindis[
   
     50010
   
     ];


   
     void
   
      Init()
{
 
   
     int
   
      i,a,b,c;
 Edge E;
 MaxP
   
     =-
   
     1
   
     ;
 cin
   
     >>
   
     n;
 
   
     for
   
     (i
   
     =
   
     0
   
     ;i
   
     <
   
     n;i
   
     ++
   
     )
 {
 scanf(
   
     "
   
     %d%d%d
   
     "
   
     ,
   
     &
   
     a,
   
     &
   
     b,
   
     &
   
     c);
 
   
     if
   
     (a
   
     >
   
     b)
 swap(a,b);
 E.v
   
     =
   
     b
   
     +
   
     1
   
     ;
 E.c
   
     =
   
     c;
 head[a].push_back(E);
 
   
     if
   
     (MaxP
   
     <
   
     b)
 MaxP
   
     =
   
     b;
 }
 
   
     for
   
     (i
   
     =
   
     0
   
     ;i
   
     <=
   
     MaxP;i
   
     ++
   
     )
 {
 E.v
   
     =
   
     i;
 E.c
   
     =-
   
     1
   
     ;
 head[i
   
     +
   
     1
   
     ].push_back(E);
 E.v
   
     =
   
     i
   
     +
   
     1
   
     ;
 E.c
   
     =
   
     0
   
     ;
 head[i].push_back(E);
 mindis[i]
   
     =
   
     inf;
 }
 mindis[
   
     0
   
     ]
   
     =
   
     0
   
     ;
 mindis[MaxP
   
     +
   
     1
   
     ]
   
     =
   
     inf;
}


   
     void
   
      SPFA()
{
 queue
   
     <
   
     int
   
     >
   
      Q;
 
   
     int
   
      vis[
   
     50010
   
     ]
   
     =
   
     {
   
     0
   
     };
 Q.push(
   
     0
   
     );
 vis[
   
     0
   
     ]
   
     =
   
     1
   
     ;
 
   
     while
   
     (
   
     !
   
     Q.empty())
 {
 
   
     int
   
      u
   
     =
   
     Q.front();
 Q.pop();
 vis[u]
   
     =
   
     0
   
     ;
 
   
     for
   
     (
   
     int
   
      i
   
     =
   
     0
   
     ;i
   
     <
   
     head[u].size();i
   
     ++
   
     )
 {
 
   
     if
   
     (mindis[head[u][i].v]
   
     <
   
     mindis[u]
   
     +
   
     head[u][i].c)
 {
 mindis[head[u][i].v]
   
     =
   
     mindis[u]
   
     +
   
     head[u][i].c;
 
   
     if
   
     (
   
     !
   
     vis[head[u][i].v])
 {
 vis[head[u][i].v]
   
     =
   
     1
   
     ;
 Q.push(head[u][i].v);
 }
 }
 }
 }
}


   
     void
   
      Solve()
{
 SPFA();
 cout
   
     <<
   
     mindis[MaxP
   
     +
   
     1
   
     ]
   
     <<
   
     endl;
}


   
     int
   
      main()
{
 Init();
 Solve(); 
 
   
     return
   
      
   
     0
   
     ;
}