计蒜客 7.22 K. Mario Kart（01背包+最短路）

题意：在一个一维的坐标轴上，给定n个点的位置，还给定m种硬币，每个硬币都有一个C和V，C代表这种硬币的花费，V代表这种硬币可以传送的距离。题目还给定一个L，如果两个点之间的最小花费超过L那么两个点之间不能达到。

思路：

先用01背包处理一下所有可能的距离，然后每两个点之间判断一下是否能到达。再根据是否能到达建图。

最后跑一下Dijkstra或者BFS都行，当然对于这个题目BFS更好写。

code：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <stack>
#include <map>
#include <sstream>
#include <cstring>
#include <set>
#include <cctype>
#include <bitset>
#define IO                       \
    ios::sync_with_stdio(false); \
    // cin.tie(0);                  \
    // cout.tie(0);
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
// int dis[8][2] = {0, 1, 1, 0, 0, -1, -1, 0, 1, -1, 1, 1, -1, 1, -1, -1};
const int maxn = 1e4 + 10;
const int maxm = 1e6 + 10;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int inf = 0x3f3f3f3f;
const LL mod = 1e9 + 7;
struct Edge
{
    int next, to, w;
} e[maxn];
int n, m, L, k;
int p[maxn], c[maxn], v[maxn], head[maxn];
int dis[maxn];
int dp[maxn];
bool vis[maxn];
void add(int u, int v, int w) //  链式前向星 加边函数
{
    e[k].to = v;
    e[k].w = w;
    e[k].next = head[u];
    head[u] = k++;
}
int Dijkstra(int s)
{
    memset(vis, false, sizeof vis); // 一开始所有点均没有被访问过
    memset(dis, inf, sizeof dis);   // 将距离设为一个比较大的数
    dis[s] = 0;                     // 第一个点的 dis 初始设置为 0
    typedef pair<int, int> P;
    priority_queue<P, vector<P>, greater<P>> pq; // STL 中的优先队列默认按照第一个元素进行排序
    pq.push({0, 1});                             // 初始 距离 0 点为 1
    while (!pq.empty())
    {
        P now = pq.top();
        pq.pop();
        int u = now.second;
        if (vis[u] == true)
            continue;
        vis[u] = true;
        for (int i = head[u]; i != -1; i = e[i].next)
        {
            int v = e[i].to;
            if (dis[v] > dis[u] + e[i].w)
            {
                dis[v] = dis[u] + e[i].w;
                pq.push({dis[v], v});
            }
        }
    }
    if (dis[n] == inf)
        return -1;
    return dis[n];
}
int BFS(int s)
{
    memset(vis, false, sizeof vis);
    vis[1] = true;
    typedef pair<int, int> P;
    queue<P> q;
    q.push({1, 0}); // 1 到 自己的距离 为 0
    while (!q.empty())
    {
        P now = q.front();
        q.pop();
        int u = now.first;
        if (u == n)
            return now.second;
        for (int i = head[u]; i != -1; i = e[i].next)
        {
            int v = e[i].to;
            if (vis[v] == false)
            {
                vis[v] = true;
                P t;
                t.first = v;
                t.second = now.second + 1;
                q.push(t);
            }
        }
    }
    return -1;
}
int main()
{
#ifdef ONLINE_JUDGE
#else
    freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
#endif
    IO;
    int T;
    cin >> T;
    while (T--)
    {
        cin >> n >> m >> L;
        memset(head, -1, sizeof head);
        k = 0;
        for (int i = 1; i <= n; i++)
            cin >> p[i];
        for (int i = 1; i <= m; i++)
            cin >> c[i] >> v[i];
        sort(p + 1, p + n + 1);
        int maxdis = p[n] - p[1]; // 最大的可能距离

        for (int i = 1; i <= maxdis; i++)
            dp[i] = inf; // 先设置为 无穷大

        dp[0] = 0;
        for (int i = 1; i <= m; i++) // 01 背包处理
            for (int j = maxdis; j >= v[i]; j--)
                dp[j] = min(dp[j], dp[j - v[i]] + c[i]); // 这里用到了滚动数组优化

        for (int i = 1; i <= n; i++)
            for (int j = i + 1; j <= n; j++)
            {
                if (i == j)
                    add(i, j, 0), add(j, i, 0);
                else
                {
                    if (dp[p[j] - p[i]] <= L)
                        add(i, j, 1), add(j, i, 1);
                    // else
                    //     add(i, j, inf), add(j, i, inf); // 用 Dijstra 需要把这两行加上
                }
            }
        // cout << Dijkstra(1) << "\n";
        cout << BFS(1) << "\n";
    }

    return 0;
}