Candies(差分约束)

http://poj.org/problem?id=3159

题意：

flymouse是幼稚园班上的班长，一天老师给小朋友们买了一堆的糖果，由flymouse来分发，在班上，
flymouse和snoopy是死对头，两人势如水火，不能相容，因此fly希望自己分得的糖果数尽量多于
snoopy，而对于其他小朋友而言，则只希望自己得到的糖果不少于班上某某其他人就行了。

比如A小朋友强烈希望自己的糖果数不能少于B小朋友m个，即B- A<=m，A，B分别为
A、B小朋友的分得的糖果数。这样给出若干组这样的条件，要使fly最后分得的糖果数s1和snoopy
最后分得的糖果数s2差别取到最大！即s2-s1取最大.

思路：求源点1到n的最短距离。Dijstra+邻接表

不过直接用dij会超时。可以用优先队列优化一下。不过运算符重载那里被卡了好久。悲惨的教训啊。

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;

const int INF = 0x3f3f3f3f;
const int maxv = 30100;
const int maxe = 150100;
struct node
{
    int v,w,next;
}edge[maxe];//邻接表

struct node1
{
    int v,c;
    bool operator < (const node1 &t) const
    {
        return c > t.c;//距离从小到大排序
    }
};//存每个节点和它到源点的最短距离。

int n,m,cnt;
int p[maxe];
int dis[maxv];
int vis[maxv];
void add(int u, int v, int w)
{
    cnt++;
    edge[cnt].v = v;
    edge[cnt].w = w;
    edge[cnt].next = p[u];
    p[u] = cnt;
}

void dijstra(int s)
{
    priority_queue<struct node1> que;
    for(int i = 1; i <= n; i++)
        dis[i] = INF;
    memset(vis,0,sizeof(vis));

    dis[s] = 0;
    que.push((struct node1){s,dis[s]});
    for(int i = 0; i < n; i++)
    {
        while(!que.empty() && vis[que.top().v])
            que.pop();
        if(que.empty()) break;

        node1 tmp = que.top();
        que.pop();
        vis[tmp.v] = 1;
        for(int j = p[tmp.v]; j; j = edge[j].next)
        {
            if((dis[edge[j].v] > dis[tmp.v] + edge[j].w) && !vis[edge[j].v])
            {
                dis[edge[j].v] = dis[tmp.v] + edge[j].w;
                que.push((struct node1){edge[j].v,dis[edge[j].v]});
            }
        }
    }
}

int main()
{
    while(~scanf("%d %d",&n,&m))
    {
        int u,v,w;
        memset(p,0,sizeof(p));
        cnt = 0;
        for(int i = 0; i < m; i++)
        {
            scanf("%d %d %d",&u,&v,&w);
            add(u,v,w);
        }
        dijstra(1);
        printf("%d
",dis[n]);

    }
    return 0;
}

 看discuss里面也可以用SPFA+stack，可能用stack效率高一点吧。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<stack>
using namespace std;

const int INF = 0x3f3f3f3f;
const int maxv = 30100;
const int maxe = 150100;

struct node
{
    int v,w;
    int next;
}edge[maxe];
int n,m,cnt;
int p[maxe];
int dis[maxv],instack[maxv];
void add(int u, int v, int w)
{
    cnt++;
    edge[cnt].v = v;
    edge[cnt].w = w;
    edge[cnt].next = p[u];
    p[u] = cnt;
}

void SPFA(int s)
{
    stack<int>st;
    for(int i = 1; i <= n; i++)
        dis[i] = INF;
    memset(instack,0,sizeof(instack));
    dis[s] = 0;
    st.push(s);
    instack[s] = 1;
    while(!st.empty())
    {
        int u = st.top();
        st.pop();
        instack[u] = 0;

        for(int i = p[u]; i; i = edge[i].next)
        {
            if(dis[edge[i].v] > dis[u] + edge[i].w)
            {
                dis[edge[i].v] = dis[u] + edge[i].w;
                if(!instack[edge[i].v])
                {
                    st.push(edge[i].v);
                    instack[edge[i].v] = 1;
                }
            }
        }
    }
}

int main()
{
    while(~scanf("%d %d",&n,&m))
    {
        cnt = 0;
        memset(p,0,sizeof(p));
        int u,v,w;
        for(int i = 0; i < m; i++)
        {
            scanf("%d %d %d",&u,&v,&w);
            add(u,v,w);
        }
        SPFA(1);
        printf("%d
",dis[n]);
    }
    return 0;
}