POJ 1062题解 Dijkstra

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

题解：

以b[1].l-m——b[1].l为下界，进行枚举x，每次等级在x——x+m范围之内的才能走通(范围必须卡在m之间)。

求出从1到各个节点的最短路径，那么b[i]+dis[i]就是直接买i物品，通过一些列的换取，得到了1物品。

采用枚举即：假设酋长等级为5，等级限制为2，那么需要枚举等级从3~5,4~6,5~7
从满足改等级范围的结点组成的子图中用Dijkstra来算出最短路径，最后求出最小值。

#include<vector>
#include<stdio.h>
#include<string.h>
#include<math.h>
#define inf 0x7f7f7f
#include<queue>
#define maxn 109
using namespace std;
struct node {
    int u,c;
    node(int u,int c):u(u),c(c){};
    node() {};
    friend bool operator <(node a,node b) {
        return a.c>b.c;
    }
} tmp;
struct Edge {
    int to;
    int dis;
    int next;
} edge[maxn*maxn*2];
int dis[maxn];
bool used[maxn];
int head[maxn];
priority_queue <node> q;
int N,M;
struct Point {
    int p,l;
} b[maxn];
void Dijkstra(int s) {
    int t,u,w;
    while(!q.empty())q.pop();
    memset(used,false,sizeof(used));
    memset(dis,inf,sizeof(dis));
    tmp=node(1,0);
    dis[1]=0;
    q.push(tmp);
    while(!q.empty()) {
        tmp=q.top();
        q.pop();
        t=tmp.u;
        if(used[t])continue;
        else used[t]=true;
        for(int i=head[t]; i!=-1; i=edge[i].next) {
            u=edge[i].to;
            w=edge[i].dis;
            if(b[u].l>(s+N)||b[u].l<s)continue;
            if(used[u])continue;
            if(dis[t]+w<dis[u]) {
                dis[u]=dis[t]+w;
                q.push(node(u,dis[u]));
            }
        }
    }
}
int E;
void add(int u,int v,int w) {
    edge[E].to=v;
    edge[E].dis=w;
    edge[E].next=head[u];
    head[u]=E++;
}
int main() {
    while(~scanf("%d %d",&N,&M)) {
        E=0;
        memset(head,-1,sizeof(head));
        for(int i=1; i<=M; i++) {
            int x,no,price;
            scanf("%d %d %d",&b[i].p,&b[i].l,&x);
            for(int j=0; j<x; j++) {
                scanf("%d %d",&no,&price);
                add(i,no,price);
            }
        }
        int ans=b[1].p;
        for(int i=b[1].l; i>=0&&i>=b[1].l-N; i--) {
            Dijkstra(i);
            for(int i=1; i<=M; i++) {
                if(ans>(dis[i]+b[i].p)) {
                    ans=(dis[i]+b[i].p);
                }
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

还有另外的一种构图的方法。

http://blog.csdn.net/lyy289065406/article/details/6645852

构图时要注意的是，酉长的承诺不是 最初的源点，它是一个目标点，也就是说点到点的指向方向是由 无替代品的点 逐渐指向到 酉长的承诺1点，题意说明的是一个回溯的过程，因此可以定义一个最初的源点0点，它到其他各点的权值就是每个物品的原价，而点A到点B的权值 就是 物品B在有第A号替代品情况下的优惠价

#include<vector>
#include<stdio.h>
#include<string.h>
#include<math.h>
#define inf 0x7f7f7f
#include<queue>
#define maxn 109
using namespace std;
struct node {
    int u,c;
    node(int u,int c):u(u),c(c){};
    node() {};
    friend bool operator <(node a,node b) {
        return a.c>b.c;
    }
} tmp;
struct Edge {
    int to;
    int dis;
    int next;
} edge[maxn*maxn*2];
int dis[maxn];
bool used[maxn];
int head[maxn];
priority_queue <node> q;
int N,M;
struct Point {
    int p,l;
} b[maxn];
void Dijkstra(int s) {
    int t,u,w;
    while(!q.empty())q.pop();
    memset(used,false,sizeof(used));
    memset(dis,inf,sizeof(dis));
    tmp=node(0,0);
    dis[0]=0;
    q.push(tmp);
    while(!q.empty()) {
        tmp=q.top();
        q.pop();
        t=tmp.u;
        if(used[t])continue;
        else used[t]=true;
        for(int i=head[t]; i!=-1; i=edge[i].next) {
            u=edge[i].to;
            w=edge[i].dis;
            if(b[u].l>(s+N)||b[u].l<s)continue;
            if(used[u])continue;
            if(dis[t]+w<dis[u]) {
                dis[u]=dis[t]+w;
                q.push(node(u,dis[u]));
            }
        }
    }
}
int E;
void add(int u,int v,int w) {
    edge[E].to=v;
    edge[E].dis=w;
    edge[E].next=head[u];
    head[u]=E++;
}
int main() {
    while(~scanf("%d %d",&N,&M)) {
        E=0;
        memset(head,-1,sizeof(head));
        for(int i=1; i<=M; i++) {
            int x,no,price;
            scanf("%d %d %d",&b[i].p,&b[i].l,&x);
            add(0,i,b[i].p);
            for(int j=0; j<x; j++) {
                scanf("%d %d",&no,&price);
                add(no,i,price);
            }
        }
        int ans=b[1].p;
        for(int i=b[1].l; i>=0&&i>=b[1].l-N; i--) {
            Dijkstra(i);
            //printf("++++%d\n",dis[1]);
            ans=ans>dis[1]?dis[1]:ans;
            //printf("----%d\n",ans);
        }
        printf("%d\n",ans);
    }
    return 0;
}