poj 1062 昂贵的聘礼 （最短路）

poj 1062 昂贵的聘礼

Description
年轻的探险家来到了一个印第安部落里。在那里他和酋长的女儿相爱了，于是便向酋长去求亲。酋长要他用10000个金币作为聘礼才答应把女儿嫁给他。探险家拿不出这么多金币，便请求酋长降低要求。酋长说：”嗯，如果你能够替我弄到大祭司的皮袄，我可以只要8000金币。如果你能够弄来他的水晶球，那么只要5000金币就行了。”探险家就跑到大祭司那里，向他要求皮袄或水晶球，大祭司要他用金币来换，或者替他弄来其他的东西，他可以降低价格。探险家于是又跑到其他地方，其他人也提出了类似的要求，或者直接用金币换，或者找到其他东西就可以降低价格。不过探险家没必要用多样东西去换一样东西，因为不会得到更低的价格。探险家现在很需要你的帮忙，让他用最少的金币娶到自己的心上人。另外他要告诉你的是，在这个部落里，等级观念十分森严。地位差距超过一定限制的两个人之间不会进行任何形式的直接接触，包括交易。他是一个外来人，所以可以不受这些限制。但是如果他和某个地位较低的人进行了交易，地位较高的的人不会再和他交易，他们认为这样等于是间接接触，反过来也一样。因此你需要在考虑所有的情况以后给他提供一个最好的方案。
为了方便起见，我们把所有的物品从1开始进行编号，酋长的允诺也看作一个物品，并且编号总是1。每个物品都有对应的价格P，主人的地位等级L，以及一系列的替代品Ti和该替代品所对应的”优惠”Vi。如果两人地位等级差距超过了M，就不能”间接交易”。你必须根据这些数据来计算出探险家最少需要多少金币才能娶到酋长的女儿。

Input
输入第一行是两个整数M，N（1 <= N <= 100），依次表示地位等级差距限制和物品的总数。接下来按照编号从小到大依次给出了N个物品的描述。每个物品的描述开头是三个非负整数P、L、X（X < N），依次表示该物品的价格、主人的地位等级和替代品总数。接下来X行每行包括两个整数T和V，分别表示替代品的编号和”优惠价格”。

Output
输出最少需要的金币数。

Sample Input

1 4
10000 3 2
2 8000
3 5000
1000 2 1
4 200
3000 2 1
4 200
50 2 0

Sample Output

5250

题目大意：中文题。

解题思路：如果一个物品A，可以用另一个物品B加上更少的钱C换到的话，B就可以向A建一条权值为C的边。然后要考虑等级差距的问题，枚举每一个物品，将当前物品的等级当做是最高级别，然后排除等级差距大于M的交换，以及等级比当前物品等级高的交换，跑最短路，求出到物品1的最短路。答案就是多次最短路中的最小值。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <queue>
using namespace std;

const int INF = 0x3f3f3f3f;
const int N = 1000;
const int M = 10000;
typedef long long ll;
int n, k;
int val[N], le[N];
int Gra[N][N], vis[N], d[N];
struct Edge{  
    int from,to;  
    ll dist;  
};  
struct HeapNode{
    int d,u;  
    bool operator < (const HeapNode& rhs) const{  
        return d > rhs.d;  
    }  
};  
struct Dijkstra{  
    int n,m;               //点数和边数  
    vector<Edge> edges;    //边列表  
    vector<int> G[M];     //每个结点出发的边编号（从0开始编号）  
    bool done[N];         //是否已永久标号  
    int d[N];             //s到各个点的距离  
    ll L; 

    void init(int n) {  
        this->n = n;  
        for(int i = 0; i <= M; i++) G[i].clear();//清空邻接表  
        edges.clear();//清空边表  
    }  

    void addEdge(int from, int to, ll dist) {   
        //如果是无向图，每条无向边需调用两次AddEdge  
        edges.push_back((Edge){from, to, dist});
        m = edges.size();
        G[from].push_back(m - 1);
    }  

    int dijkstra(int s) {//求s到所有点的距离  
        priority_queue<HeapNode> Q;  
        for(int i = 1; i <= n; i++) d[i] = INF;  
        d[s] = 0;
        memset(done, 0, sizeof(done));
        Q.push((HeapNode){0, s});  
        while(!Q.empty()){  
            HeapNode x = Q.top(); Q.pop();  
            int u = x.u;  
            if (done[u] || vis[u]) continue;
            done[u] = true;
            for(int i = 0; i < G[u].size(); i++){  
                Edge& e = edges[G[u][i]];  
                if(d[e.to] > d[u] + e.dist && !vis[e.to]){  
                    d[e.to] = d[u] + e.dist;  
                    Q.push((HeapNode){d[e.to], e.to});  
                }  
            }  
        }  
        return d[1];
    }  
}dij; 

void input() {
    int temp, a, b;
    for (int i = 1; i <= n; i++) {
        scanf("%d %d %d", &val[i], &le[i], &temp);  
        for (int j = 0; j < temp; j++) {
            scanf("%d %d", &a, &b); 
            dij.addEdge(a, i, b);
        }
        dij.addEdge(0, i, val[i]);
    }
}

void solve() {
    int ans = INF;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (le[i] - le[j] > k || le[i] < le[j]) vis[j] = 1;
            else vis[j] = 0;
        }   
        ans = min(ans, dij.dijkstra(0));
    }
    printf("%d\n", ans);
}

int main() {
    while (scanf("%d %d", &k, &n) == 2) {
        dij.init(n);
        input();
        solve();
    }
    return 0;
}