3.1.1 单元最短路的建图方式

最新推荐文章于 2024-02-26 07:40:22 发布
最新推荐文章于 2024-02-26 07:40:22 发布
阅读量186 收藏
点赞数
文章标签： 图论 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53029342/article/details/125690819
版权

单元最短路的建图方式

这里写目录标题

1.首先我们先来复习求单元最短路有哪些算法

在这里插入图片描述

  • 边权均非负的情况下：

    • 朴素dijkstra O(n^2)

      void dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    memset(st, 0, sizeof st);
    dist[1] = 0;
    //循环n次
    for (int k = 0; k < n; k++)
    {
        int t = 0;
        for (int j = 1; j <= n; j++)
        {
            if (!st[j] && dist[j] < dist[t])
                t = j;
        }
        st[t] = true;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            dist[j] = min(dist[j], dist[t] + w[i]);
        }
    }
}

    • 堆优化版的dijkstra O(mlog(n))

      void heap_dijkstra(int x)
{
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    memset(dist, 0x3f, sizeof dist);
    dist[x] = 0;
    heap.push({0, x});
    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();
        int u = t.y;
        if (st[u]) continue;
        st[u] = true;
        for (int i = h[u]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[u] + w[i])
            {
                dist[j] = dist[u] + w[i];
                heap.push({dist[j], j});
            }
        }
    }
}

    • spfa 最快:O(m) 最慢: O(mn)

      void spfa()
{
    memset(dist, 0x3f, sizeof dist);
    memset(st, 0, sizeof st);
    st[1] = true;
    dist[1] = 0;
    queue<int> q;
    q.push(1);
    while (q.size())
    {
        int t = q.front();
        q.pop();
        st[t] = false;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])
                    q.push(j);
            }
        }
    }
}

2.题目

题目1 ：AcWing 1129. 热浪

这道题就是一套纯裸求单源最短路的题目，用上面三种算法都可以过

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 3e3, M = N * N;
int T, C, Ts, Te;
int h[N], e[M], w[M], ne[M], idx;
int dist[N];
bool st[N];
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
void dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[Ts] = 0;
    for (int k = 1; k <= T; k++)
    {
        int t = 0;
        for (int j = 1; j <= T; j++)
        {
            if (!st[j] && dist[j] < dist[t])
            {
                t = j;
            }
        }
        if (t == Te)
        {
            return;
        }
        st[t] = true;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            dist[j] = min(dist[j], dist[t] + w[i]);
        }
    }
}
int main()
{
    memset(h, -1, sizeof h);
    cin >> T >> C >> Ts >> Te;
    for (int i = 0; i < C; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
        add(b, a, c);
    }
    dijkstra();
    cout << dist[Te];
    return 0;
}
题目2 AcWing 1128. 信使

这道题也是一道比较裸的单元最短路题目，求每一个点到其他点的最短时间，最后要求整个送信过程最短时间，所以就是最后一个得到新的哨点的时间，即max[dist[]]

#include <bits/stdc++.h>
using namespace std;
const int N = 3e3, M = N * N;
int n, m;
int h[N], e[M], w[M], ne[M], idx;
int dist[N];
bool st[N];
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
void dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for (int k = 1; k <= n; k++)
    {
        int t = 0;
        for (int j = 1; j <= n; j++)
        {
            if (!st[j] && dist[j] < dist[t])
            {
                t = j;
            }
        }
        st[t] = true;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            dist[j] = min(dist[j], dist[t] + w[i]);
        }
    }
}
int main()
{
    memset(h, -1, sizeof h);
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
        add(b, a, c);
    }
    dijkstra();
    int ans = 0;
    for (int i = 1; i <= n; i++)
    {
        ans = max(ans, dist[i]);
        if (dist[i] == 0x3f3f3f3f)
        {
            cout << -1;
            return 0;
        }
    }
    cout << ans;

    return 0;
}
题目3：AcWing 1127. 香甜的黄油

这道题不是单源最短路了，是求多源最短路，我们需要选定一个起点，求最优解，由于我们不知道哪个点是最优解，所以我们要把所有的牧场枚举一遍，求以某个牧场作为起点的路径和，最后取所有路劲和的最小值。

  • Floyd : 复杂度 O(n^3) 会超时，不可行

  • 朴素版dijkstra ，本题中，因为需要枚举每个点，所以复杂度是 n * O(n^2) = O(n^3)，n=800，所以会超时

  • 堆优化版的dijkstra, 复杂度 O(mnlog(n))，勉强可以过

  • spfa 复杂度最低：O(mn) ,如果出题人不卡的话是可以过的

所以这道题我就用spfa来写了，可以过，而且很快

#include <bits/stdc++.h>
using namespace std;
const int N = 810, M = 3000;
int h[N], w[M], ne[M], e[M], idx;
int s[N];
int dist[N];
bool st[N];
int n, p, m;
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
void spfa(int x)
{
    memset(dist, 0x3f, sizeof dist);
    memset(st, 0, sizeof st);
    st[x] = true;
    dist[x] = 0;
    queue<int> q;
    q.push(x);
    while (q.size())
    {
        int t = q.front();
        q.pop();
        st[t] = false;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])
                    q.push(j);
            }
        }
    }
}
signed main()
{
    memset(h, -1, sizeof h);
    cin >> n >> p >> m;
    for (int i = 1; i <= n; i++)
    {
        int t;
        cin >> t;
        s[t]++;
    }
    while (m--)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
        add(b, a, c);
    }
    int ans = 1e9;
    for (int i = 1; i <= p; i++)
    {
        int sum = 0;
        int f = 1;
        spfa(i);
        for (int j = 1; j <= p; j++)
        {
            if (s[j] && dist[j] == 0x3f3f3f3f)
            {
                f = 0;
                break;
            }
            sum += dist[j] * s[j];
        }
        if (f)
        {
            ans = min(ans, sum);
        }
    }
    cout << ans;
    return 0;
}
题目4：AcWing 1126. 最小花费

写图论的难点其实不在于求最短路的过程，而在于建图，把图建好了，问题也就很容易解决了。

d[] 是金钱，w[]是转账的汇率， 0<w<=1

这道题中A最少需要多少钱使得转账后B收到100元，我们可以列出这样一个式子：d[A] * w1 * w2 *... wn = d[B] = 100，A最少，那么w1 * w2 * .. wn 就要最大 ，即 求log(w1∗w2∗w3…)=log(w1)+log(w2)+…log(w1∗w2∗w3…)=log(w1)+log(w2)+… 最大，

因为w都是小于1的，所以log(w)都是小于0的，所以将每个数取相反数，
问题转化成求取反后的最小值，即转换成最短路问题，这道题我们可以发现不光加一个数可以求最短路，乘一个数也可以求最短路

我们已经将这道题解析求最短路问题，但不是真的求最短路，我们还是要求w1 * w2 * .. wn的最大值，也就是求最长路

代码

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

using namespace std;

const int N = 2010;

int n, m, S, T;
double g[N][N];
double dist[N];
bool st[N];

void dijkstra()
{
    dist[S] = 1;
    for (int i = 1; i <= n; i ++ )
    {
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] < dist[j]))
                t = j;
        st[t] = true;
        for (int j = 1; j <= n; j ++ )
            dist[j] = max(dist[j], dist[t] * g[t][j]);
    }
}

int main()
{
    scanf("%d%d", &n, &m);

    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        double z = (100.0 - c) / 100;
        g[a][b] = g[b][a] = max(g[a][b], z);
    }

    cin >> S >> T;

    dijkstra();

    printf("%.8lf\n", 100 / dist[T]);

    return 0;
}

这里还有另外一种写法，d[A] * w1 * w2 *... wn = d[B] = 100，那么可以转换为d[A] = d[B] / (w1 * w2 * ... wn),由于w<=1，所以分子小于等于1，d[B]/w>=d[A]所以为了d[A]最小，那么d[B] / w最小，那么就转换成了求由B到A的最短路问题

代码2

#include <bits/stdc++.h>
using namespace std;
const int N = 2010, M = 2e5 + 10;
int h[N], w[M], ne[M], e[M], idx;
bool st[N];
double dist[N];
int n, m;
int A, B;
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
void spfa()
{
    for (int i = 0; i <= n; i++)
        dist[i] = 1e9;
    memset(st, 0, sizeof st);
    st[B] = true;
    dist[B] = 100;
    queue<int> q;
    q.push(B);
    while (q.size())
    {
        int t = q.front();
        q.pop();
        st[t] = false;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] * 100 / (100 - w[i]))
            {
                dist[j] = dist[t] * 100 / (100 - w[i]);
                if (!st[j])
                    q.push(j);
            }
        }
    }
}
signed main()
{
    memset(h, -1, sizeof h);
    cin >> n >> m;
    while (m--)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
        add(b, a, c);
    }
    cin >> A >> B;
    spfa();
    printf("%.8lf", dist[A]);
    return 0;
}

总结

  • 当算乘积最值的最短路时，如果乘数都>=0,那么就边权都为非负数，那么可以用dijkstra...
  • 如果乘数有<0的，那么只能用spfa...
题目5：AcWing 920. 最优乘车

这道题就非常考验建图能力了

分析：题目时要求最少换乘次数，换乘不好求，我们可以先求坐车次数，坐车次数-1=换乘次数,因为第一上车不算换乘，那么在一条线路a b c d中，我们可以假设从a上车，那么走到 b c d任意一个站都需要上车一次就可以到达，从b上车，那么走到c d任意一个站也只需要上车一次就可以到达，假设现在还有另一条线路c e f ，我们要到f 站，就可以从c点下车，在上到这辆车上做到f，那么c 到f也只需要上车一次就可以了。

这样我们就可以知道如何建图了，只要在一条线路上可以到达，那么这两个站就可以连一条边权为1的边，最后就变成了从1到n的最短路问题

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> Q;
#define x first
#define y second
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
const int N = 1000, M = 1e3;
int m, n;
int h[N], w[M], ne[M], e[M], idx;
int dist[N];
bool st[N];
void add(int a, int b, int c)  // 添加一条边a->b，边权为c
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

void dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    Q q;
    q.push({0, 1});
    while (q.size())
    {
        auto t = q.top();
        q.pop();
        int u = t.y;
        if(st[u])
            continue;
       	st[u] = true;
        for (int i = h[u]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[u] + w[i])
            {
                dist[j] = dist[u] + w[i];
                q.push({dist[j], j});
            }
        }
    }
    return ;
}
int main()
{
    cin >> m >> n;
    getchar();
    memset(h, -1, sizeof h);
    while (m--)
    {
        string s;
        getline(cin, s);
        vector<int> v;
        int k = 0;
        for (int i = 0; i < s.size(); i++)
        {

            if (isdigit(s[i]))
                k = k * 10 + s[i] - '0';
            else
            {
                v.push_back(k);
                k = 0;
            }
        }
        v.push_back(k);
        for (int i = 0; i < v.size() - 1; i++)
        {
            for (int j = i + 1; j < v.size(); j++)
            {
                add(v[i], v[j], 1);
            }
        }
    }
    dijkstra();
    if(dist[n] == 0x3f3f3f3f)
    cout <<"NO";
    else
    cout << dist[n] - 1;
    return 0;
}
题目4：AcWing 903. 昂贵的聘礼

这道题还是考验建图分析模型能力

分析：取酋长的女儿需要10000个金币，但是探险家拿不出这么多金币，但是可以通过其他物品交换来代替这10000个金币，酋长说：”嗯，如果你能够替我弄到大祭司的皮袄，我可以只要 8000 金币。如果你能够弄来他的水晶球，那么只要 5000 金币就行了。” 那么娶酋长女儿 = 10000 = 皮袄 + 8000 = 水晶球 + 5000，10000个金币我没有，那这俩替代品是不是可以弄来呢，所以又用其他东西来换，到最后探险家如何用最少的金币娶他的女儿呢？

（这让我想起了之前看到的一些视频关于如何用一块钱去和别人换东西，用换来的物品在和其他人交换，最后通过1块钱换到了很贵重的东西，哈哈哈，有机会我也想试一试）

我们先来建立一下模型：

在这里插入图片描述

建立模型之后，我们发现这题就是求单源最短路的问题，最终是求到酋长女儿的最少金币，题目已经给出n个物品的信息，那用什么来表示探险家呢，这里我们可以建立一个虚拟源点，用0号点表示，用0号点来向其他点建图，最后求一边最短路即可。

还要这道题有个要求，就是交换的东西之间都有一个等级，不能超过一个范围，探险家最终要和酋长女儿交换，所以她俩的等级差不能超过范围，其他所有交换的中介都不能超过这个范围，直接枚举探险家的等级即可，最后算最小值。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef priority_queue<int, vector<int>, less<int>> Q;
#define x first
#define y second
const int N = 110, M = N * N;
int h[N], w[M], ne[M], e[M], idx;
bool st[N];
int dist[N];
int level[N];
int n, m;
int ans = 1e9;
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
void spfa(int l, int r)
{
    memset(dist, 0x3f, sizeof dist);
    memset(st, 0, sizeof st);
    st[0] = true;
    dist[0] = 0;
    queue<int> q;
    q.push(0);
    while (q.size())
    {
        int t = q.front();
        q.pop();
        st[t] = false;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (level[j] >= l && level[j] <= r && dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])
                    q.push(j);
            }
        }
    }
}
signed main()
{
    memset(h, -1, sizeof h);
    cin >> m >> n;
    for (int i = 1; i <= n; i++)
    {
        int c, l, cnt;
        cin >> c >> level[i] >> cnt;
        add(0, i, c);
        while (cnt--)
        {
            int t, v;
            cin >> t >> v;
            add(t, i, v);
        }
    }
	// 等级范围
    for (int i = level[1] - m; i <= level[1]; i++)
    {
        spfa(i, i + m);
        ans = min(ans, dist[1]);
    }
    cout << ans;
    return 0;
}
总结

通过本节我们学到了关于如果求单元最短路的一些问题，重点在如何建图上，将问题转化为图论模型。

  • 虚拟源点
  • 建图
  • 边权（加 / 乘）
  • 多源最短路转化为单元最短路

有任何疑问欢迎评论区留言哦

背书包的小新
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单元最短路经 Dijkstra算法 可输出路径
01-27
略作修改，不仅可算出路径，而且可以将路径打印。
bzoj 2259 [Oibh]新型计算机 ——最短路（建图）
weixin_34050427的博客
12-02 104
题目：https://www.lydsy.com/JudgeOnline/problem.php?id=2259 不是 n^2 条边！连那条边权为0的边之后，只要每个位置向它的前一个位置和后一个位置连 1 的边，就能等价于一开始就走到那个位置了。 不会有情况使得操作后 a[ i ] 变成负数来走到 j 。因为那样一定不如走到 i 的时候别走到 i 而是直接走到 j 。 注意1号点。如果每个点...
acwing算法基础全总结
最新发布
2302_80729149的博客
02-26 842
acwing算法基础课笔记思路，含代码
单元最短路
梦载代码
06-30 603
Problem Description 给n个城市和联通城市间的m条道路，每条路有个距离d和走这条路所花费的时间p。给你出发城市s和终点城市e,要求输出从起点到终点的最短距离及其花费的时间， 如果有多条最短路径，输出花费时间最少的一条。 Input 首先输入n,m，城市的编号是1-n 接下来是m行，每行包含4个数字a,b,d,p，表示a城市和b城市之间有一条路，路径长度为
谈谈单元最短路
weixin_30319097的博客
06-10 299
单元最短路，应该会立即想到spfa和dijkstra。 相较而言，我用spfa的次数更加多一些， 一般这些题目都可以用　　spfa（算法）+（数据结构）边表给做掉， 借用了 这位大神的论文。 我们一般用的都是spfa的bfs应用，这是比较正确的，一般情况下 bfs算法优势明显，但是为什么还需要dijkstra呢？ 如上图，这里的话，可以发现spfa的弱点就...
单元最短路问题
Bruce
08-12 655
1.单元最短路问题（Bellman-Ford算法）贪心策略，始终选择从出发点s到达顶点i的当前最短距离为d[i].那么就会出现下列推导关系： d[i]=min{d[j]+cost[j][i]|e=(j,i)属于E}(其中cost(j,i)表示从顶点j到顶点i的权值) 如果给定的图是DAG，那么就可以按拓扑序给顶点编号，并且利用上述推到关系计算，但是如果给定图 中有圈，就无法依照这样的顺序来进行计
MQTT 协议 3.1.1 中文版
07-07
MQTT 协议 3.1.1 中文版
Piwik 网站统计系统 v3.1.1
11-28
Piwik是一套基于Php+MySQL技术构建的开源网站访问统计系统，前身是phpMyVisites。Piwik 网站统计系统可以给你详细的统计信息，比如网页 浏览人数 访问最多的页面 搜索引擎关键词等等，并
HDFView-3.1.1.msi
04-23
HDFView-3.1.1.msi,拖入nc文件可以查看内相关内容，名称等，不通过代码即可实现。在进行文件读取前可以更好的浏览，为后面文件提取做准备。
jquery-3.1.1.min.js
04-18
jquery-1.8.3.min.js jquery-1.9.1.min.js ...jquery-3.1.1.min.js 集合了5个版本的jquery， 另外注释：jquery版本非越高越好，请酌情选择，jquery2.0以上不支持ie8以下，Jquery3.0以上新增xss攻击防御
StarUML-3.1.1.AppImage
11-18
建模工具StarUML-3.1.1.AppImage
分支界限法求单元点最短路径
12-14
分支界限法求单元点最短路径 代码 实验报告
【算法】单源最短路——Dijkstra
CFhM_R's Blog
03-01 3139
对于固定起点的最短路算法，我们称之为单源最短路算法。单源最短路算法很多，最常见的就是dijkstra算法。 dijkstra主要用的是一种贪心的思想，就是说如果i...s...t...j是最短路，那么i和j之间的任意两点s,t之间也一定是最短路，非常好证，如果s，t之间不是最短路，那么必然存在最短路，那么i到j也不是最短路造成了矛盾。 而dijkstra就是运用这样的思想，把起点首先放进一个集
POJ-2502 Subway( 最短路建图 )
running_acmer的博客
05-24 430
题意：人走路的速度是10km/h，地铁的速度是40km/h题目给出一个起点，一个终点，以及几条地铁线路运行的站点。题目给的点的做坐标单位是m把速度统一为m/min，答案输出从起点到终点的时间，到最近的分钟数。10km/h= 10000/60 m/min，40km/h= 40000/60 m/min所有的点直接以步行的速度建边。地铁线路两站相邻的以地铁速度建边总结：这题主要在于建图与输入#inclu...
单元最短路径-Dijkstra算法
ertcmmy的博客
05-31 493
普通方法 const int INF = 10000; const int MAX_V = 100; int cost[MAX_V][MAX_V]; // 花费 int d[MAX_V]; // 起始顶点到所有顶点最短距离 bool S[MAX_V]; // 是否在集合中 int V = 7; // 顶点数 // 传入的是起始顶点 void dijkstra(int s){ fill(d, ...
[Acwing] 最优乘车 最短路建图
qq_34364611的博客
10-25 106
前言 考虑建图 用sstreamsstreamsstream 处理读入一行很巧妙 传送门 : 思路 我们可以 给 一条路线上的所有点都连一条边 这样子处理的话,我们就可以不用考虑 中途是否换车的问题 我们只需要都连一条边 并且 付边权为 111 即可 最后跑一遍最短路就行 CODE #include <iostream> #include <algorithm> #include <sstream> #include <cstring> using nam
【HDU - 4725 The Shortest Path in Nya Graph】【最短路建图】【拆层】【好题】
running_acmer的博客
02-18 228
http://acm.hdu.edu.cn/showproblem.php?pid=4725 【题意】 给你n个点，每个点有一个层的位置 有m条边，连接两点，并且相邻层之间可以通过c来到达 【思路】 将每个层拆出来作为一个点建图 点与点：原来的m条边建双向边 层与层：相邻层建c的双向边 点与层：层到层上的点的距离为0，点到相邻层代表的点为c 注意：相同层上的点的距离不为0 【代...
最短路正反建图
HHeyanjie的博客
10-30 219
链接: 题目. 题意：输入n m x 表示有n个点 m条边 终点是x，要求输出每个点到终点然后回来的最大值。 思路：如果正向跑，每个点开始跑一变dij求出每个点到终点距离和终点到每个点距离，肯定会T，所以改变一下思路，存一个正向图和一个反向图，正向图从x点跑一边最短路，可以得出终点到每个点的最短路，反向图也从x点跑一边最短路，因为反向图，所以可以得出每个点到终点的最短路。最后取两个dis相加的最大值。 代码 #include <iostream> #include <cstdio>
单元点最短路问题Dijkstra算法堆优化模板
_C9的博客
05-02 159
模板处理的是有向图，如果是无向图只需要再把节点正反赋两次值就可以了 #include<iostream> #include<vector> #include<queue> using namespace std; typedef pair<int,int> pr; typedef long long ll; const ll MAX_N=1e5+5; const ll INF=1e9+5; ll n,m; vector<pr> e[MAX_N
maven3.1.1
08-30
Maven 3.1.1 是一个用于软件项目构建、依赖管理和项目信息管理的工具。它是Maven开源项目的一个版本。 Maven 3.1.1 在Maven 3.1.0 基础上进行了一些更新和修复。它提供了更稳定和高效的构建流程，并改善了Maven的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值