Mr. Panda and Crystal HDU

题目：题目链接

思路：不难看出，合成每个宝石需要消耗一定的魔力值，每个宝石有一定的收益，所以只要我们知道每个宝石合成的最小花费，该题就可以转化为一个背包容量为初始魔力值的完全背包问题，每个宝石的最小花费可以用dijkstra跑一遍最短路算出，路径长度用合成花费表示。

AC代码：

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

using namespace std;

const int maxn = 10000 + 5;

int vol, n, m, INF;

struct node {
    int c, w;
    vector<int> v;
    vector<vector<pair<int, int> > > vec;
    friend bool operator < (node a, node b) {
        return a.w > b.w;
    }
}gem[maxn];

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>> > q;

bool vis[maxn];

void init() {
    for(int i = 1; i <= n; ++i) {
        for(int j = 0; j < gem[i].vec.size(); ++j)
            gem[i].vec[j].clear();
        gem[i].vec.clear();
        gem[i].v.clear();
    }
    while(!q.empty()) 
        q.pop();
    memset(vis, false, sizeof(vis));
}

bool get_sum(int id) {
    int sum, _min = INF;
    for(int i = 0; i < gem[id].vec.size(); ++i) {
        sum = 0;
        for(int j = 0; j < gem[id].vec[i].size(); ++j) {
            sum += gem[gem[id].vec[i][j].first].c * gem[id].vec[i][j].second;
            if(sum > INF)
                sum = INF;
        }
        _min = min(_min, sum);
    }
    if(_min < gem[id].c) {
        gem[id].c = _min; 
        return true;
    }
    return false;
}

void dijkstra() {
    while(!q.empty()) {
        pair<int, int> P = q.top();
        q.pop();
        if(vis[P.second])
            continue;
        vis[P.second] = true;
        for(int i = 0; i < gem[P.second].v.size(); ++i) {
            if(!vis[gem[P.second].v[i]] && get_sum(gem[P.second].v[i])) {
                q.push(make_pair(gem[gem[P.second].v[i]].c, gem[P.second].v[i]));
            }
        }
    }
}

int dp[maxn];

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);

    int T, t = 0;
    cin >> T;
    while(T--) {
        cin >> vol >> n >> m;
        INF = vol + 1;
        init();
        int flag;
        for(int i = 1; i <= n; ++i) {
            cin >> flag;
            if(flag)
                cin >> gem[i].c >> gem[i].w;
            else {
                cin >> gem[i].w;
                gem[i].c = INF;
            }
        }
        int id, num, c, nu;
        vector<pair<int, int> > ope;
        for(int i = 0; i < m; ++i) {
            cin >> id >> num;
            ope.clear();
            for(int j = 0; j < num; ++j) {
                cin >> c >> nu;
                ope.push_back(make_pair(c, nu));
                gem[c].v.push_back(id);
            }
            gem[id].vec.push_back(ope);
        }

        for(int i = 1; i <= n; ++i) 
            if(gem[i].c < INF)
                q.push(make_pair(gem[i].c, i));

        dijkstra();

        memset(dp, 0, sizeof(dp));
        for(int i = 1; i <= n; ++i) 
            for(int v = 0; v <= vol; ++v)
                if(v >= gem[i].c)
                    dp[v] = max(dp[v], dp[v - gem[i].c] + gem[i].w);
    
        cout << "Case #" << ++t << ": " << dp[vol] << endl;
    }
    return 0;
}