昂贵的聘礼——dijkstra+枚举区间

一、题目

年轻的探险家来到了一个印第安部落里。在那里他和酋长的女儿相爱了，于是便向酋长去求亲。酋长要他用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

二、思路

• 建立一个超级源点0，从0建立一条边到每个物品，权值为物品的价值。代表花费多少钱就可以购买这个物品。
   

• 若某个物品拥有替代品，代表从替代品建立一条边到这个物品，价值为替代的价值。 代表我有了这个替代品，那么还需要花费多少就能买这个物品。
   
  

• 最后就是等级制度。我们可以枚举每个等级区间，每次求最短路是只能更新在这个区间里面的物品。枚举所有情况求一个最小值就可以了。 特别注意的是区间必须包含1点。 那么范围就是【L[1] - m, L[1]】
   
  参考自https://xiaoxiaoh.blog.csdn.net/article/details/104198067

• 关于等级制度的处理。对于从u点出发到w点的路径种，他会跟很多等级的人交易，然而必须满足在路径中的点等级不超过一个M值。从题意中我们知道，最后所有的最短路都会汇集在1号点，也就是说1号点是所有最短路径存在的点，根据这个结论我们依据1号点来给定区间。假设1号点等级为lev，那么也就是说在所有最短的这些点必须满足在$[lev-m,lev+m]$这个区间里面。但是这个区间是不符合规范的，这个区间里面包含有子区间超过M长度的（显然这是存在的），所以我们要继续缩小可以取到的区间。最终整个这个大区间可以分解成这样的小区间：$[lev-m,lev],[lev-m+1,lev+1],[lev-m+1,lev+2]\dots [lev,lev+m]$,因为这些区间都是大区间的子区间，所以是必定满足大区间的条件，在这些区间里面筛选最短路径就不会超出题目所规定的“等级”。
   

• 例：假设酋长的等级是5，等级限制是2。那么需要枚举的区间就是 3~ 5，4~ 6，5~7

• 算法使用的是dijkstra算法，存图用的是链式前向星存图（当然也可以用其他方法存图）
   

c++代码

#include<cstdio>
#include<queue>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAX = 500,INF = 0x3f3f3f3f;

int head[MAX],d[MAX],L[MAX],maxl=INF,len=1,M,N,P,X,T,V;
bool use[MAX];

struct Map
{
    int to,w,next;
}edge[MAX];


void add(int u,int v,int w)
{
    edge[len].w = w;
    edge[len].to = v;
    edge[len].next = head[u];
    head[u] = len++;
}

void dijkstra(int l,int r)
{
    memset(d,0x3f,sizeof(d));
    d[0] = 0;
    queue<int> q;
    q.push(0);
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        use[u] = false;
        for(int j=head[u];j;j = edge[j].next)
        {
            int v = edge[j].to;
            int w = edge[j].w + d[u];
            if(l<=L[v] && L[v] <= r && d[v]>w)  // 如果这个点的等级在允许的范围内并且它的当前值要比更新后的值要大，我们将它更新
            {
                d[v] = w;
                if(!use[v]) // 标记改点已经用过，避免重复搜索
                {
                    use[v] = true;
                    q.push(v);
                }
            }
        }
    }
}

int main()
{
    scanf("%d %d",&M,&N);
    for(int u=1;u<=N;u++)
    {
        scanf("%d%d%d",&P,&L[u],&X);
        maxl = max(maxl,L[u]);
        add(0,u,P);
        while(X--)
        {
            scanf("%d%d",&T,&V);
            add(T,u,V);
        }
    }
    
    int ans = INF;
    for(int i=L[1]-M;i<=L[1];i++)  // 枚举区间可以取到的区间
    {
        dijkstra(i,i+M);
        ans = min(d[1], ans);    // 每搜索完一次更新一次最小金币
    }
    printf("%d",ans);
    return 0;
}

 

用邻接表存图(个人觉得此方法更优)

#include<map>
#include<queue>
#include<cstdio>
#include<vector>
#include<iostream>
using namespace std;

const int INF = 0x3f3f3f3f,MAX_V = 500;
int M,N,C,X,T,A,L[MAX_V],d[MAX_V];

typedef pair<int,int> P;
int V=1;

struct edge
{
    int to,cost;
};
vector<edge> G[MAX_V];

void dijkstra(int l,int r)
{
    priority_queue<P, vector<P>, greater<P> > que;
    fill(d,d+MAX_V,INF);
    d[0] = 0;
    que.push(P(0,0));

    while(!que.empty())
    {
        P p = que.top(); que.pop();
        int v = p.second;
        if(d[v] < p.first) continue;
        for(int i = 0;i<G[v].size();i++)
        {
            edge e = G[v][i];
            int w = e.cost;
            if(l <= L[e.to] && L[e.to] <= r && d[e.to] > d[v] + w)
            {
                d[e.to] = d[v] + w;
                que.push(P(d[e.to],e.to));
            }
        }
    }
}

int main()
{
    scanf("%d%d",&M,&N);
    for(int u=1;u<=N;u++)
    {
        scanf("%d%d%d",&C,&L[u],&X);
        V++;
        G[0].push_back({u,C});
        while(X--)
        {
            scanf("%d%d",&T,&A);
            G[T].push_back({u,A});
            V++;
        }
    }

    int ans = INF;
    for(int i=L[1]-M;i<=L[1];i++)
    {
        dijkstra(i,i+M);
        ans = min(ans,d[1]);
    }
    printf("%d\n",ans);
    
    return 0;
}