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[5], D[5];
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 = 0; i < 4; ++i)
        if(L[i] < n && n <= L[i+1]) 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 = 0;
    memset(vis, false, sizeof(vis));
    memset(eh, -1, sizeof(eh));
    for(int i = 0; i < nv; ++i)
    for(int j = i+1; j < nv; ++j)
    {
        Type road = cord[i] - cord[j];
        if(road < 0) 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 = 0; i < nv; ++i) dist[i] = INF;
    dist[s] = 0;
    priority_queue<Edge> que;
    que.push(Edge(s, 0));
    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 != -1; 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 = 1; t <= T; ++t)
    {
        for(int i = 1; i < 5; ++i)
            scanf("%I64d", &L[i]);
        for(int i = 0; i < 4; ++i)
            scanf("%I64d", &D[i]);
        L[0] = 0;
        scanf("%d%d", &nv, &ne);
        for(int i = 0; i < nv; ++i)
            scanf("%I64d", &cord[i]);
        init();
        printf("Case %d:
", t);
        for(int i = 0, u, v; i != ne; ++i)
        {
            scanf("%d%d", &u, &v);
            SPFA(u-1);
            if(dist[v-1] == INF)
                printf("Station %d and station %d are not attainable.
", u, v);
            else
                printf("The minimum cost between station %d and station %d is %I64d.
", u, v, dist[v-1]);
        }
    }
    return 0;
}