最短路 2016.9.1

最新推荐文章于 2016-09-07 20:08:11 发布
最新推荐文章于 2016-09-07 20:08:11 发布
阅读量328 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Only_AiR/article/details/51604062
版权

1、UVa 10048 Audiophobia

参考：http://blog.csdn.net/shuangde800/article/details/7985085

题意：
c1到c2的每条路径的声强为这条路径所包含的边的最大权值
求c1到c2的声强最小的一条路径的声强

解题思路：
Floyd变形

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

using namespace std;

const int INF = 0x3f3f3f3f;
const int maxn = 100 + 10;
int Graph[maxn][maxn];
int C, S, Q;

void Floyd(void);

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif
    int Case = 0;
    while (scanf("%d%d%d", &C, &S, &Q) != EOF && !(C == 0 && S == 0 && Q == 0)) {
        for (int i = 1; i <= C; ++i) {
            for (int j = 1; j <= C; ++j) {
                if (i == j) {
                    Graph[i][j] = 0;
                } else {
                    Graph[i][j] = INF;
                }
            }
        }
        int c1, c2, d;
        for (int i = 0; i < S; ++i) {
            scanf("%d%d%d", &c1, &c2, &d);
            Graph[c1][c2] = Graph[c2][c1] = d;
        }
        Floyd();
        ++Case;
        if (Case > 1) {
            printf("\n");
        }
        printf("Case #%d\n", Case);
        for (int i = 0; i < Q; ++i) {
            scanf("%d%d", &c1, &c2);
            if (Graph[c1][c2] != INF) {
                printf("%d\n", Graph[c1][c2]);
            } else {
                printf("no path\n");
            }
        }
    }
    return 0;
}

void Floyd(void)
{
    for (int k = 1; k <= C; ++k) {
        for (int i = 1; i <= C; ++i) {
            for (int j = 1; j <= C; ++j) {
                Graph[i][j] = min(Graph[i][j], max(Graph[i][k], Graph[k][j]));
            }
        }
    }
}

2、POJ 1135 Domino Effect

参考：http://www.cnblogs.com/liuxueyang/archive/2013/05/05/3060536.html

题意;

计算多米诺骨牌全部倒下需要的时间以及最后倒的位置


解题思路：

Dijkstra 求出每 i 个骨牌倒下需要的时间 dis[i]

如果最后倒在端点处，只要求出 max_dis 就可以了

如果倒在两个端点之间，那么需要求出 max_((dis[i] + dis[j] + Graph[i][j]) / 2.0) (Graph[i][j] != INF)

我们只要比较 这两个最大值就可以确定最后倒在哪里


注意：用 printf 输出用 %.1f，不要用 %.1lf， 否则会 wa（以前听说 %lf 会 wa，今天终于遇到了

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;

const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int maxn = 500 + 10;
int n, m;
int Graph[maxn][maxn];
int dis[maxn];
bool vis[maxn];

void Dijkstra(void);

int main()
{
    int System = 0;
    while (scanf("%d%d", &n, &m) != EOF && !(n ==0 && m == 0)) {
        ++System;
        printf("System #%d\n", System);
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (i == j) {
                    Graph[i][j] = 0;
                } else {
                    Graph[i][j] = INF;
                }
            }
        }
        int a, b, l;
        for (int i = 0; i < m; ++i) {
            scanf("%d%d%d", &a, &b, &l);
            Graph[a][b] = Graph[b][a] = l;
        }
        Dijkstra();
        double Max1 = -INF;
        int pos;
        for (int i = 1; i <= n; ++i) {
            if (dis[i] > Max1) {
                Max1 = dis[i];
                pos = i;
            }
        }
        double Max2 = -INF;
        int pos1, pos2;
        for (int i = 1; i <= n; ++i) {
            for (int j = i+1; j <= n; ++j) {
                if (Graph[i][j] != INF) {
                    double t = (dis[j] + dis[i] + Graph[i][j]) / 2.0;
                    if (t > Max2) {
                        Max2 = t;
                        pos1 = i; pos2 = j;
                    }
                }
            }
        }
        if (Max2 > Max1) {
            printf("The last domino falls after %.1f seconds, between key dominoes %d and %d.\n", Max2, pos1, pos2);
        } else {
            printf("The last domino falls after %.1f seconds, at key domino %d.\n", Max1, pos);
        }
        printf("\n");
    }
    return 0;
}

void Dijkstra(void)
{
    memset(vis, false, sizeof(vis));
    for (int i = 1; i <= n; ++i) {
        dis[i] = Graph[1][i];
    }
    for (int i = 0; i < n-1; ++i) {
        int Min = INF;
        int t;
        for (int j = 2; j <= n; ++j) {
            if (!vis[j] && dis[j] < Min) {
                Min = dis[j];
                t = j;
            }
        }
        if (Min == INF) {
            break;
        }
        vis[t] = true;
        for (int j = 2; j <= n; ++j) {
            if (!vis[j] && dis[j] > dis[t] + Graph[t][j]) {
                dis[j] = dis[t] + Graph[t][j];
            }
        }
    }
}

3、团队程序设计天梯赛-练习集-L2-001 紧急救援

解题思路：

dijkstra变形，第一个输出的是最短路的条数

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <cmath>
#include <cctype>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;

const ull mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int maxn = 500 + 10;
int N, M, S, D;
int num[maxn];
int Graph[maxn][maxn];
int dis[maxn];
bool vis[maxn];
int sum[maxn];
int pre[maxn];
int pathnum[maxn];

void Dijkstra(void);

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    scanf("%d%d%d%d", &N, &M, &S, &D);
    for (int i = 0; i < N; ++i) {
        scanf("%d", &num[i]);
    }
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            if (i == j) {
                Graph[i][j] = 0;
            } else {
                Graph[i][j] = INF;
            }
        }
    }
    int a, b, len;
    for (int i = 0; i < M; ++i) {
        scanf("%d%d%d", &a, &b, &len);
        Graph[a][b] = min(len, Graph[a][b]);
        Graph[b][a] = Graph[a][b];
    }
    Dijkstra();
    printf("%d %d\n", pathnum[D], sum[D]);
    stack<int> Stack;
    int t = D;
    while (pre[t] != t) {
        Stack.push(t);
        t = pre[t];
    }
    printf("%d", S);
    while (!Stack.empty()) {
        printf(" %d", Stack.top());
        Stack.pop();
    }
    printf("\n");
    return 0;
}

void Dijkstra(void)
{
    memset(vis, false, sizeof(vis));
    for (int i = 0; i < N; ++i) {
        dis[i] = INF;
    }
    dis[S] = 0;
    vis[S] = true;
    sum[S] = num[S];
    pathnum[S] = 1;
    for (int i = 0; i < N; ++i) {
        if (i != S && Graph[S][i] != INF) {
            dis[i] = Graph[S][i];
            pre[i] = S;
            sum[i] = num[S] + num[i];
            pathnum[i] = 1;
        }
    }
    for (int i = 0; i < N-1; ++i) {
        int Min = INF;
        int t;
        for (int j = 0; j < N; ++j) {
            if (!vis[j] && dis[j] < Min) {
                Min = dis[j];
                t = j;
            }
        }
        if (Min == INF) {
            break;
        }
        vis[t] = true;
        for (int j = 0; j < N; ++j) {
            if (!vis[j]) {
                int dis_t = dis[t] + Graph[t][j];
                if (dis_t < dis[j]) {
                    dis[j] = dis_t;
                    pre[j] = t;
                    pathnum[j] = pathnum[t];
                    sum[j] = sum[t] + num[j];
                } else if (dis_t == dis[j]) {
                    pathnum[j] += pathnum[t];
                    if (sum[j] < sum[t] + num[j]) {
                        sum[j] = sum[t] + num[j];
                        pre[j] = t;
                    }
                }
            }
        }
    }
}

4、HDU 2066 一个人的旅行

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <cmath>
#include <cctype>
#include <bitset>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int, int> Pair;

const ull mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int maxn = 1e3 + 10;
int T, S, D;
int G[maxn][maxn];
int dis[maxn];
bool vis[maxn];
int Citys_num = 0;

void Dijkstra(void);

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    while (scanf("%d%d%d", &T, &S, &D) != EOF) {
        int a, b, time;
        for (int i = 0; i < maxn; ++i) {
            for (int j = 0; j < maxn; ++j) {
                if (i == j) {
                    G[i][j] = 0;
                } else {
                    G[i][j] = INF;
                }
            }
        }
        Citys_num = 0;
        while (T--) {
            scanf("%d%d%d", &a, &b, &time);
            if (time < G[a][b]) {
                G[a][b] = G[b][a] = time;
                Citys_num = max(Citys_num, max(a, b));
            }
        }
        for (int i = 1; i <= Citys_num; ++i) {
            dis[i] = INF;
        }
        int Connect_City;
        while (S--) {
            scanf("%d", &Connect_City);
            dis[Connect_City] = 0;
        }
        Dijkstra();
        int Min = INF;
        int Target_City;
        while (D--) {
            scanf("%d", &Target_City);
            if (dis[Target_City] < Min) {
                Min = dis[Target_City];
            }
        }
        printf("%d\n", Min);
    }
    return 0;
}

void Dijkstra(void)
{
    memset(vis, false, sizeof(vis));
    for (int i = 0; i < Citys_num; ++i) {
        int Min = INF;
        int t;
        for (int j = 1; j <= Citys_num; ++j) {
            if (!vis[j] && dis[j] < Min) {
                Min = dis[j];
                t = j;
            }
        }
        if (Min == INF) {
            break;
        }
        vis[t] = true;
        for (int j = 1; j <= Citys_num; ++j) {
            if (!vis[j] && dis[j] > dis[t] + G[t][j]) {
                dis[j] = dis[t] + G[t][j];
            }
        }
    }
}

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <cmath>
#include <cctype>
#include <bitset>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int, int> Pair;

const ull mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int maxn = 1e3 + 10;
int T, S, D;
int G[maxn][maxn];
int dis[maxn];
int Citys_num = 0;

struct Node {
    int End, dis;
    Node(int a, int b) {
        End = a, dis = b;
    }
    bool operator < (const Node& a) const {
        if (dis == a.dis) {
            return a.End > End;
        }
        return a.dis < dis;
    }
};

priority_queue<Node> Q;

void Dijkstra(void);

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    while (scanf("%d%d%d", &T, &S, &D) != EOF) {
        while (!Q.empty()) {
            Q.pop();
        }
        int a, b, time;
        for (int i = 0; i < maxn; ++i) {
            for (int j = 0; j < maxn; ++j) {
                if (i == j) {
                    G[i][j] = 0;
                } else {
                    G[i][j] = INF;
                }
            }
        }
        Citys_num = 0;
        while (T--) {
            scanf("%d%d%d", &a, &b, &time);
            if (time < G[a][b]) {
                G[a][b] = G[b][a] = time;
                Citys_num = max(Citys_num, max(a, b));
            }
        }
        for (int i = 1; i <= Citys_num; ++i) {
            dis[i] = INF;
        }
        int Connect_City;
        while (S--) {
            scanf("%d", &Connect_City);
            dis[Connect_City] = 0;
            Q.push(Node(Connect_City, 0));
        }
        Dijkstra();
        int Min = INF;
        int Target_City;
        while (D--) {
            scanf("%d", &Target_City);
            if (dis[Target_City] < Min) {
                Min = dis[Target_City];
            }
        }
        printf("%d\n", Min);
    }
    return 0;
}

void Dijkstra(void)
{
    while (!Q.empty()) {
        int End_t = Q.top().End, dis_t = Q.top().dis;
        Q.pop();
        for (int i = 1; i <= Citys_num; ++i) {
            if (dis[i] > dis_t + G[End_t][i]) {
                dis[i] = dis_t + G[End_t][i];
                Q.push(Node(i, dis[i]));
            }
        }
    }
}

5、POJ 2502 Subway

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <cmath>
#include <cctype>
#include <bitset>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int, int> Pair;

const ull mod = 1e9 + 7;
const double INF = 1e30;
const int maxn = 300;

vector<Pair> coordinate;
double G[maxn][maxn];
double Time[maxn];
bool vis[maxn];
double dis_t;
int Size;
int station[maxn];
int Sta_Count = 0;

double dis(int x1, int y1, int x2, int y2);

int Push(int x, int y);
void Dijkstra(void);

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    coordinate.clear();
    for (int i = 0; i < maxn; ++i) {
        for (int j = 0; j < maxn; ++j) {
            if (i == j) {
                G[i][j] = 0;
            } else {
                G[i][j] = INF;
            }
        }
    }
    int x, y;
    scanf("%d %d", &x, &y);
    coordinate.push_back(make_pair(x, y));
    scanf("%d %d", &x, &y);
    coordinate.push_back(make_pair(x, y));
    while (scanf("%d %d", &x, &y) != EOF) {
        Sta_Count = 0;
        station[Sta_Count++] = Push(x, y);
        while (scanf("%d %d", &x, &y) != EOF && !(x == -1 && y == -1)) {
            station[Sta_Count++] = Push(x, y);
        }
        for (int i = 0; i < Sta_Count-1; ++i) {
            dis_t = dis(coordinate[station[i]].first, coordinate[station[i]].second, coordinate[station[i+1]].first, coordinate[station[i+1]].second);
            G[station[i]][station[i+1]] = G[station[i+1]][station[i]] = dis_t * 3.0 / 2000.0;
        }
    }
    ++Size;
    for (int i = 0; i < Size-1; ++i) {
        for (int j = i+1; j < Size; ++j) {
            dis_t = dis(coordinate[i].first, coordinate[i].second, coordinate[j].first, coordinate[j].second);
            G[i][j] = G[j][i] = min(G[i][j], dis_t * 3.0 / 500.0);
        }
    }
    Dijkstra();
    printf("%d\n", (int)floor(Time[1] + 0.5));
    return 0;
}

double dis(int x1, int y1, int x2, int y2)
{
    return sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
}

int Push(int x, int y)
{
    Size = coordinate.size();
    for (int i = 0; i < Size; ++i) {
        if (x == coordinate[i].first && y == coordinate[i].second) {
            return i;
        }
    }
    coordinate.push_back(make_pair(x, y));
    return Size;
}

void Dijkstra(void)
{
    memset(vis, false, sizeof(vis));
    for (int i = 1; i <= Size; ++i) {
        Time[i] = G[0][i];
    }
    for (int i = 0; i < Size-1; ++i) {
        double Min = INF;
        int t = -1;
        for (int j = 1; j < Size; ++j) {
            if (!vis[j] && Time[j] < Min) {
                Min = Time[j];
                t = j;
            }
        }
        if (t == -1) {
            break;
        }
        vis[t] = true;
        for (int j = 1; j < Size; ++j) {
            if (!vis[j] && Time[j] > Time[t] + G[t][j]) {
                Time[j] = Time[t] + G[t][j];
            }
        }
    }
}

__AiR_H
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最短路问题及其应用.pdf
03-30
最短路问题及其应用.pdf最短路问题及其应用.pdf最短路问题及其应用.pdf最短路问题及其应用.pdf最短路问题及其应用.pdf
hpu暑假训练【最短路思路以及模板】
tian_he_he的博客
08-05 220
/* n个点，m条边，求1 - n 的距离 输入x y z，表示x到y的距离为z 不存在输出-1 */ #include #include #include #include using namespace std; #define INF 0x3f3f3f3f struct Pair { int first,second; //first存点，second存距离 bo
最短路模版
嗯。
04-20 998
SPFA bool SPFA() { memset(inq, false, sizeof(inq)); for(int i = 0; i <= n; i++) d[i] = INF; d[0] = 0; queue Q; Q.push(0); inq[0] = true; while(!Q.empty()) { int u = Q.front(); Q.pop();
2016.9.3总结
cdy1206473601的博客
09-07 211
这题目坑啊~坑死了！第一题，一看水题！直接刷刷刷~刷完了！那这题怎么做呢，只需要用一个双重循环，爆搜每一个点，把他们配对交换一遍，然后判断就行了。但是要注意，后面要换回来，不然你就死翘翘了~ 第二题，一开始我傻逼用dfs做，结果不知道怎么回事，是答案错误还是时间超限，只得了20分，好惨~但是，如果我按我之前找到的那个规律走，我就能对了！呜呜~~真惨! 第三题，其实可以用一个dfs直接打过，最主
2016.5.9
haliofwu的专栏
05-09 536
最近想要看的资料： 1.async /wind.js/step 2.《代码大全》 3.原型函数 4.mysql看完 5.jquery/bootstrap/ 6.移动端开发经验 今日学习进度： 1.http://blog.fens.me/series-nodejs/ 《nodejs从零开始》。不是很详细，很多个工具不熟悉。 2.js 中"||""&&" Js代码 va
基于MATLAB的 Floyd最短路算法.zip
04-20
基于MATLAB的 Floyd最短路算法.zip
BFS 找最短路.cpp
07-23
题解：Bfs找最短路径（正解，绝对正确）这是c++中一道题的题解
matlab最短路.txt
08-11
matlab最短路.txt
最短路matlab代码.zip
07-11
最短路matlab代码
node-v11.6.0-sunos-x64.tar.xz
05-02
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
node-v12.12.0-linux-s390x.tar.xz
05-02
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于统计分析的葡萄酒评价指标建立以及方案设计.doc
05-02
本文档是课题研究的研究报告内含调研以及源码设计以及结果分析
node-v12.9.1-linux-ppc64le.tar.xz
最新发布
05-02
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
多线程应用程序设计.pdf
05-02
多线程应用程序设计.pdf
什么是蚁群算法路径规划matlab以及学习蚁群算法路径规划matlab的意义
05-02
蚁群算法路径规划matlab
IEC 60695-11-3：2012.pdf
05-02
IEC 60695-11-3：2012.pdf
仿eplie触屏版html5响应式手机wap网站模板下载.zip
05-02
触屏版自适应手机wap软件网站模板 触屏版自适应手机wap软件网站模板
node-v12.1.0-linux-ppc64le.tar.xz
05-02
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
gb 9706.1-2020对高频电刀
08-04
GB 9706.1-2020是中国国家标准中的一项规定，适用于高频电刀的安全性能要求。高频电刀是一种医疗器械，常用于手术和治疗中，通过高频电能来切割、凝固、止血等操作。 根据GB 9706.1-2020的规定，高频电刀应满足以下...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值