HDU ACM 1690 Bus System （SPFA）

Bus System

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 5190    Accepted Submission(s): 1275

【题目链接】http://acm.hdu.edu.cn/showproblem.php?pid=1690

【解题思路】SPFA求最短路径问题，将每个站之间的距离转化为相应的价格从而建立两站点相连的边，其中如果距离超出了题目给的价表，那么就说明这两点不连接，连接的边的权值为价表相应区间的价格，这题数据有点大，需要用long long，不过我在用long long的时候出现两个问题

问题1：关于long long 报错的问题，本地编译器没问题，用G++提交后出错：

在用long long 类型声明和定义一个变量时，明显地在其表示范围内赋值，却得到如下的错误：

error: integer constant is too large for "long" type

来自 http://china.xilinx.com/support/answers/31999.html 的解释：

 /*Description
  *When I define a long long integer data type in SW application in EDK, a warning / error similar to the following occurs:
  *"warning: integer constant is too large for 'long' type".
  *Example:
  */

 int main ()
 {
 long long int test = 0x0008888000000000;
 }

 /*SOLUTION
  *The warning message can be safely ignored, as mb-gcc is not doing anything wrong; the 64-bit computing is in fact correct.
  *This warning occurs because gcc is strict in syntax and requires LL on the end of such constants.
  *This warning message disappears if the integer is appended with LL.
  */

 long long int test = 0x0008888000000000LL;

后来在网上搜到这样的一个解释（http://hi.baidu.com/zealot886/item/301642b0e98570a9ebba932f）：

 /*PS: 英语是硬伤，还是没搞懂原因，字面上的意思是说C不够聪明去判断左边的类型，类型仅仅是文本上的属性，不是我们所看到的的语境？
  *
  *The letters 100000000000 make up a literal integer constant, but the value is too large for the type int.
  *You need to use a suffix to change the type of the literal, i.e.
  *
  *    long long num3 =100000000000LL;
  *
  *The suffix LL makes the literal into type long long.
  *C is not "smart" enough to conclude this from the type on the left,
  *the type is a property of the literal itself, not the context in which it is being us.
  */

问题2：在用位运算给long long 类型赋值的时候，出现下面的Warning：

　　　　left shift count >= width of type

上网找了下，想到应该跟问题1应该有点联系，1 在这里是int型，需要进行显式转换才能进行左移，明显地溢出

 #include <cstdio>
 #include <queue>
 #include <cstring>
 #define NV 102
 #define NE NV*NV

 using namespace std;

 //typedef __int64 LL;
 typedef long long LL;
 typedef LL Type;
 const long long INF = 9223372036854775800LL;

 int nv, ne, tot;
 Type dist[NV], cord[NV];
 int eh[NV];
 Type L[], D[];
 bool vis[NV];

 struct Edge{
     int u, v, next;
     Type cost;
     Edge(){}
     Edge(int a, Type c) : u(a), cost(c) {}
     Edge(int a, int b, Type c, int d) : u(a), v(b), cost(c), next(d) {}
     bool operator < (const Edge& x) const {
         return cost > x.cost;
     }
 }edge[NE];

 Type get_price(Type n)
 {
     for(int i = ; i < ; ++i)
         if(L[i] < n && n <= L[i+]) return D[i];
     return INF;
 }

 void addedge(int a, int b, Type c)
 {
     Edge e = Edge(a, b, c, eh[a]);
     edge[tot] = e;
     eh[a] = tot++;
     return;
 }

 void init()
 {
     tot = ;
     memset(vis, false, sizeof(vis));
     memset(eh, -, sizeof(eh));
     for(int i = ; i < nv; ++i)
     for(int j = i+; j < nv; ++j)
     {
         Type road = cord[i] - cord[j];
         if(road < ) road = -road;
         Type price = get_price(road);
         if(price != INF)
         {
             addedge(i, j, price);
             addedge(j, i, price);
         }
     }
     return;
 }

 void SPFA(int s)
 {
     for(int i = ; i < nv; ++i) dist[i] = INF;
     dist[s] = ;
     priority_queue<Edge> que;
     que.push(Edge(s, ));
     vis[s] = true;
     while(!que.empty())
     {
         Edge tmp = que.top();
         que.pop();
         int u = tmp.u;
         vis[u] = false;
         for(int i = eh[u]; i != -; i = edge[i].next)
         {
             int v = edge[i].v;
             if(dist[v] > edge[i].cost + dist[u])
             {
                 dist[v] = edge[i].cost + dist[u];
                 if(!vis[v])
                 {
                     que.push(Edge(v, dist[v]));
                     vis[v] = true;
                 }
             }
         }
     }
     return;
 }

 int main()
 {
     #ifndef ONLINE_JUDGE
     freopen("F:\\test\\input.txt", "r", stdin);
     #endif
     int T, m;
     scanf("%d", &T);
     for(int t = ; t <= T; ++t)
     {
         for(int i = ; i < ; ++i)
             scanf("%I64d", &L[i]);
         for(int i = ; i < ; ++i)
             scanf("%I64d", &D[i]);
         L[] = ;
         scanf("%d%d", &nv, &ne);
         for(int i = ; i < nv; ++i)
             scanf("%I64d", &cord[i]);
         init();
         printf("Case %d:\n", t);
         for(int i = , u, v; i != ne; ++i)
         {
             scanf("%d%d", &u, &v);
             SPFA(u-);
             if(dist[v-] == INF)
                 printf("Station %d and station %d are not attainable.\n", u, v);
             else
                 printf("The minimum cost between station %d and station %d is %I64d.\n", u, v, dist[v-]);
         }
     }
     return ;
 }