题目描述

年轻的探险家来到了一个印第安部落里。

在那里他和酋长的女儿相爱了，于是便向酋长去求亲。

酋长要他用 10000 个金币作为聘礼才答应把女儿嫁给他。

探险家拿不出这么多金币，便请求酋长降低要求。

酋长说：”嗯，如果你能够替我弄到大祭司的皮袄，我可以只要 8000 金币。如果你能够弄来他的水晶球，那么只要 5000 金币就行了。”

探险家就跑到大祭司那里，向他要求皮袄或水晶球，大祭司要他用金币来换，或者替他弄来其他的东西，他可以降低价格。

探险家于是又跑到其他地方，其他人也提出了类似的要求，或者直接用金币换，或者找到其他东西就可以降低价格。

不过探险家没必要用多样东西去换一样东西，因为不会得到更低的价格。

探险家现在很需要你的帮忙，让他用最少的金币娶到自己的心上人。

另外他要告诉你的是，在这个部落里，等级观念十分森严。

地位差距超过一定限制的两个人之间不会进行任何形式的直接接触，包括交易。

他是一个外来人，所以可以不受这些限制。

但是如果他和某个地位较低的人进行了交易，地位较高的的人不会再和他交易，他们认为这样等于是间接接触，反过来也一样。

因此你需要在考虑所有的情况以后给他提供一个最好的方案。

为了方便起见，我们把所有的物品从 1 开始进行编号，酋长的允诺也看作一个物品，并且编号总是 1。

每个物品都有对应的价格 P，主人的地位等级 L，以及一系列的替代品Ti和该替代品所对应的”优惠” Vi。

如果两人地位等级差距超过了 M，就不能”间接交易”。

你必须根据这些数据来计算出探险家最少需要多少金币才能娶到酋长的女儿。

输入格式

输入第一行是两个整数 M，N，依次表示地位等级差距限制和物品的总数。

接下来按照编号从小到大依次给出了 N 个物品的描述。

每个物品的描述开头是三个非负整数 P、L、X，依次表示该物品的价格、主人的地位等级和替代品总数。

接下来 X 行每行包括两个整数 T 和 V，分别表示替代品的编号和”优惠价格”。

输出格式

输出最少需要的金币数。

数据范围

$1≤N≤100$,
$1≤P≤10000$,
$1≤L,M≤N$,
$0≤X<N$,

样例

IN

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

OUT

5250

算法1

(Flody) $O(n^4)$

枚举每一个等级的区间

把优惠后的价格看成边权，最后统计的结果是边权加上当前所在点的w[i]
最后一定会原价购买一件物品，即最后的w[i]

本质上是从上往下推的思考方式（实现方式可以是其他算法）

枚举每一个等级的区间

时间复杂度 $10^8$

第一重循环：避免间接发生的level值 [l - p, l]
第二至四重：floyd及其每次的初始化

根据题目数据来看应该是$10^8$的运算量，很危险，用floyd。

运行时间 1759 ms

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, p;
int dist[N][N], back_up[N][N], level[N], w[N];

int main()
{
    memset(dist, 0x3f, sizeof dist);
    scanf("%d%d", &p, &n);
    for(int i = 1; i <= n; i ++)
        dist[i][i] = 0;
    for(int i = 1; i <= n; i ++)
    {
        int k;
        scanf("%d%d%d", &w[i], &level[i], &k);
        for(int j = 0; j < k; j ++)
        {
            int b;
            scanf("%d", &b);
            scanf("%d", &dist[i][b]);
        }
    }

    memcpy(back_up, dist, sizeof back_up);

    int res = INF;

    for(int l = level[1]; l <= level[1] + p; l ++)
    {
        memcpy(dist, back_up, sizeof dist);
        for(int i = 2; i <= n; i ++)
            if(level[i] < l - p || level[i] > l)
                for(int j = 1; j <= n; j ++)
                    dist[i][j] = dist[j][i] = INF;

        for(int k = 1; k <= n; k ++)
            for(int i = 1; i <= n; i ++)
                for(int j = 1; j <= n; j ++)
                    dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);

        for(int i = 1; i <= n; i ++)
            res = min(res, dist[1][i] + w[i]);
    }

    // for(int i = 1; i <= n; i ++)
    // {
    //     for(int j = 1; j <= n; j ++)
    //         cout << dist[i][j] << ' ';
    //     cout << endl;
    // }

    cout << res << endl;

    return 0;
}

算法2

(朴素dijkstra) $O(n^3)$

其实实现方式也可以与上面的做法类似，做p次dijkstra即可

这里给出的做法是

建立一个虚拟源点，源点到每一个点的最小距离看作从空手到买一个到这个点的最小花费。

本质上是一种从下往上思考方式，是买一个然后换一个的操作方式。

枚举每一个等级的区间

时间复杂度 $10^6$

一重循环循环level的范围
后两重用于dijkstra

参考文献

算法提高课

运行时间 48 ms

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

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int g[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;
    for(int i = 0; i < n; i ++)
    {
        int u = -1;
        for(int j = 0; j <= n; j ++) // 从零号点开始循环为了开始时放入
            if(!st[j] && (u == -1 || dist[u] > dist[j]))
                u = j;
        st[u] = true;
        for(int j = 1; j <= n; j ++)
            if(level[j] >= down && level[j] <= up)
                dist[j] = min(dist[j], dist[u] + g[u][j]);
    }

    return dist[1];
}
int main()
{
    scanf("%d%d", &m, &n);
    memset(g, 0x3f, sizeof g);
    for(int i = 1; i <= n; i ++)
        g[i][i] = 0;

    for(int i = 1; i <= n; i ++)
    {
        int p, cnt;
        scanf("%d%d%d", &p, &level[i], &cnt);
        g[0][i] = min(g[0][i], p);
        while(cnt --)
        {
            int id, cost;
            scanf("%d%d", &id, &cost);
            g[id][i] = min(g[id][i], cost);
        }
    }

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

    printf("%d\n", res);

    return 0;
}

注意

line 23 从零号点开始循环为了开始时放入

总结

两种思考方式，第二种在找更新结果的值的时候不需要再去遍历一边去找开头了。