『POJ1 1062』昂贵的聘礼 {两种解法 + 详细注释}

思路：

1. 建立一个超级源点0，从0建立一条边到每个物品，边权为每个物品的价值。边权 == 代表花钱买下这个物品。
2. 若某个物品X有替代品，等价于建立一条有向边：替代品 ----》物品X，边权为物品X用该替代品折扣后的价格。 代表我有了这个替代品，那么还需要花费多少就能买这个物品。
3. 若此时没有等级的限制，求的是从花费的金额的最小值是多少，那么我们可以直接从虚拟源点做一遍dijkstra算法，然后返回dist[1]；
4. 但是本题有等级限制，限制范围：{ level[1] - m, level[1] }；而任何一个位于合法区间里的点，都有可能更新，而我们也只更新合法区间里的点，所以要枚举所有的合法区间(合法：包含目的地的区间！)，因为区间里面的中转点可能不同，你所借助的中转点也会不同，从而导致所花费的金额也不一定！

代码：

朴素版的Dijkstra算法

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int w[N][N], level[N];
int dist[N];
bool st[N];

int dijkstra(int down, int up)
{
    memset(dist, 0x3f, sizeof dist);
    memset(st, 0, sizeof st);

    dist[0] = 0;
//一共n个点，循环n-1次即可，这里是n+1个点，所以循环n次就行了。
//如果是n个点，循环n-1次就行了，至于说是小于等于还是小于，取决于起点下标从1开始还是从0开始！
//其实这里与什么 <=无关，因为外层循环只是决定了它单纯地循环多少次，而i甚至不会用到，所以说循环
//n次也是可以的，保险起见，以后n个点我都循环n次，免得出现它有n+1个点，我分析不到n+1的情况！
    for (int i = 0; i < n; i ++ )
    {
        int t = -1;
        for (int j = 0; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                 t = j;

        st[t] = true;
        for (int j = 1; j <= n; j ++ )
            if (level[j] >= down && level[j] <= up)
                dist[j] = min(dist[j], dist[t] + w[t][j]);
    }

    return dist[1];
}

int main()
{
    cin >> m >> n;

    memset(w, 0x3f, sizeof w);
    for (int i = 1; i <= n; i ++ ) w[i][i] = 0;

    for (int i = 1; i <= n; i ++ )
    {
        int price, cnt;
        cin >> price >> level[i] >> cnt;
        w[0][i] = min(price, w[0][i]);
        while (cnt -- )
        {
            int id, cost;
            cin >> id >> cost;
            w[id][i] = min(w[id][i], cost);
        }
    }

    int res = INF;
    for (int i = level[1] - m; i <= level[1]; i ++ ) res = min(res, dijkstra(i, i + m));

    cout << res << endl;

    return 0;
}

堆优化版本的dijkstra算法：

1. 由题意可得，每个物品都可以是起点，即从当前物品买着走，直到买到1号物品，抽象成一条路的形式。

2. 该做法起点过多，不宜与写最短路。所以我们可以利用多源bfs的思想。即建立虚拟源点，然后又由于每个物品都可以做为起点，所以以虚拟源点向每个物品连接一条边权为物品价值的边，若要走该路，说明需要购买该物品。（遇到多起点的最短路问题我们可以用一个虚拟源点向这些点建立边就可以把多起点问题转化为单源点最短路径。）

3. 如果没有阶级限制那我们可以直接从虚拟源点向所有点连边边权为这些点的距离，然后跑一遍最短路径这样就可以得到我们最小花费的金币数

4. 但是如果有了阶级限制我们该怎么解决呢？答案是我们可以枚举所有包涵1的阶级区间然后在这些区间跑最短路然后整体取最小值，这样就可以得到我们要花费的最小金币数了
   总结经验：
   当某一个算法加了某种限制的话，可考虑枚举在合法的限制下，进行算法的限制，算法本身不变
   。
   堆优化版本的dijkstra算法：
   暂时没有ac！

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#define x first
#define y second

using namespace std;
typedef pair<int, int> PII;

const int N = 1e2 + 10, inf = 0x3f3f3f3f;
int h[N], e[N], ne[N], w[N], idx;
int n, m;
int level[N], price[N];
bool st[N];
int dist[N];

void add (int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

int dijkstra (int down, int up)
{
    priority_queue<PII> heap;
    heap.push({0, 0});
    
    memset (dist, 0x3f, sizeof (dist));
    dist[0] = 0;
    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();
        int v = t.y;
        
        if (st[v]) continue;
        st[v] = true;
        
        for (int i=h[v]; ~i; i = ne[i])
        {
            int j = e[i];
            
            if (level[j] >= down && level[j] <= up)
            {
                if (dist[j] > dist[v] + w[i])
                {
                    dist[j] = dist[v] + w[i];
                    heap.push({dist[j], j});
                }
            }
        }
    }
    
    return dist[1];
}

int main()
{
    scanf("%d%d", &m, &n);
    memset(h, -1, sizeof h);
    
    for (int i=1; i <= n; i ++)
    {
        int cnt;
        cin >> price[i] >> level[i] >> cnt; //输入的是物品的价值，等级，替代品数量
        
        for (int i=1; i <= cnt; i ++)
        {
            int t, v;
            cin >> t >> v;
            add (t, i, v);
        }
    }
    
    //建立虚拟源点：
    for (int i=1; i <= n; i ++)
        add (0, i, price[i]);
    
    int res = inf;
    for (int i = level[1]-m; i <= level[1]; i ++)
    {
        res = min(res, dijkstra(i, i + m));
    }
    cout << res << endl;
    return 0;
}