POJ 1062 昂贵的聘礼——Dijkstra/DFS

传送门

题意： （反正题目就是中文的，理解起来应该不会有太大问题）
题解： 一看就知道是最短路问题，但因为有个等级限制需要做一些小小的处理，最简单的是一开始就框定一个等级范围，然后在范围内的才进行交换，然后更新最小值。当然这样需要遍历所有范围，进行多次最短路求解（在这个问题里是不会超时的。也因为这个交易是单向的，所以用DFS搜索也挺方便的。

Dijkstra解决

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
const int inf = 0x3f3f3f3f;
const int num = 105;

int m, n;
int level[num];
struct edge{
    int from, to, w;
    edge(int a, int b, int c){from = a;to = b;w = c;}
};
vector<edge>e[num];

int Dijkstra(int l, int r){
    int dis[num];
    bool vis[num];
    for (int i = 0; i <= n; i++){
        dis[i] = inf;
        vis[i] = false;
    }
    dis[0] = 0;
    queue<int>q;
    q.push(0);
    while(!q.empty()){
        int u = q.front();
        q.pop();
        vis[u] = 0;
        for (int i = 0; i < e[u].size(); i++){
            int v = e[u][i].to, w = e[u][i].w;
            if (level[v] < l || level[v] > r)
                continue;
            if (dis[v] > dis[u] + w){
                dis[v] = dis[u] + w;
                q.push(v);
            }
       }
    }
    return dis[1];
}
int main(){
    cin >> m >> n;
    for (int i = 1; i <= n; i++){
        int p, l, k;
        cin >> p >> l >> k;
        e[0].push_back(edge(0, i, p));
        level[i] = l;
        while(k--){
            int b, c;
            cin >> b >> c;
            e[b].push_back(edge(b, i, c));
        }
    }
    int ans = inf;
    for (int i = level[1] - m; i <= level[1]; i++)
        ans = min(Dijkstra(i, i + m), ans);
    cout << ans;
    return 0;
}

DFS解决

#include<iostream>
#include<vector>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;

int n, m, result;
bool vis[105];
struct node{	int price,level;}c[105];
struct mode{	int num,discount;};
vector<mode>edge[105];

void dfs(int x, int sum, int max_l, int min_l){
    result = min(result, sum);
    max_l = max(max_l, c[x].level);
    min_l = min(min_l, c[x].level);
    for (int i = 0; i < edge[x].size(); i++){
        mode temp = edge[x][i];
        if (abs(min_l - c[temp.num].level) <= m && abs(max_l - c[temp.num].level) <= m && !vis[temp.num]){//处在范围内，并且没交易过
            vis[temp.num] = true;
            dfs(temp.num, sum + temp.discount + c[temp.num].price - c[x].price,
                max(max_l, c[x].level), min(min_l, c[x].level));
            vis[temp.num] = false;
        }
    }
}

int main(){
    while (cin >> m >> n){
            memset(vis, false, sizeof vis);
            memset(edge, 0, sizeof edge);
            memset(c, 0, sizeof c);
            for (int i = 1; i <= n; i++){
                int x;
                cin >> c[i].price >> c[i].level >> x;
                for (int j = 0; j < x; j++){
                    mode temp;
                    cin >> temp.num >> temp.discount;
                    edge[i].push_back(temp);
                }
            }
            result = c[1].price;
            vis[1] = true;
            dfs(1, c[1].price, c[1].level, c[1].level);
            cout << result << endl;
    }
    return 0;
}