codeforces 59E shortest path

最新推荐文章于 2020-08-24 17:55:56 发布
最新推荐文章于 2020-08-24 17:55:56 发布
阅读量567 收藏
点赞数
分类专栏： oj odyssey 文章标签： shortest path bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ILIKUSUNYI/article/details/79372539
版权

今天终于做出了一道困扰我一学期的题，就是这道shortestpath。其要求不能连续访问某些三个城市，比如限制1 2 3， 则不能在访问完1、2后访问3.一种直白的想法（从同班同学黄毅飞那里听来的）就是以边建图，同时可以增加一个起始城市0连一条0->1的单行道，再连一条n->n+1的单行道，从而转换为0到n+1的dijkstra（但是后来发现dijkstra会超时，注意到其边权恒为1，所以可用一次bfs解决，同时记录路径即可）。代码总含有许多不成熟的地方，包括强行转换图的痕迹，请见谅，回头会修改的。

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <assert.h>
#include <set>
using namespace std;
#define MAXN 3004
#define MAXM 40010
#define HASHMOD 100003
#define INF 0x3f3f3f3f
typedef struct road {
	int fromCity;
	int toCity;
	int NO;
	struct road() {}
	struct road(int u, int v) { fromCity = u; toCity = v; }
	struct road(int u, int v, int No) { fromCity = u; toCity = v; NO = No; }
	bool operator == (struct road r) { 
		return (fromCity == r.fromCity&&toCity == r.toCity);
	}
}Road;
typedef struct cancellableVertex {
	int toNode;
	bool valid;
	struct cancellableVertex(int to) { toNode = to; valid = true; }
}CancellableVertex;
typedef struct Vertex {
	int weight;
	bool isValid;
	int pi;
}Vertex;
int allRoads[MAXN][MAXN];
Road roadIndex[MAXM];
vector<int > originalGraph[MAXN];
vector<CancellableVertex > roadGraph[MAXM];
Vertex roadVertices[MAXM];
int n, m, k, indexNumber;
int roadNumber(Road r)
{
	return allRoads[r.fromCity][r.toCity];
}
void input()
{
	memset(allRoads, 0xff, sizeof(allRoads));
	for (int i = 0; i < MAXN; i++)
		originalGraph[i].clear();
	memset(roadIndex, 0xff, sizeof(roadIndex));
	indexNumber = 0;
	for (int i = 0; i < m; i++) {
		int u, v, h;
		scanf("%d %d", &u, &v);
		if (roadNumber(Road(u, v)) < 0) {
			allRoads[u][v] = indexNumber;
			roadIndex[indexNumber] = Road(u, v,indexNumber);
			indexNumber++;
			originalGraph[u].push_back(v);
		}
		if (roadNumber(Road(v, u)) < 0) {
			allRoads[v][u] = indexNumber;
			roadIndex[indexNumber] = Road(v, u,indexNumber);
			indexNumber++;
			originalGraph[v].push_back(u);
		}
	}
	originalGraph[0].push_back(1);
	originalGraph[n].push_back(n+1);
	allRoads[0][1] = indexNumber;
	roadIndex[indexNumber] = Road(0, 1, indexNumber);
	indexNumber++;
	allRoads[n][n+1] = indexNumber;
	roadIndex[indexNumber] = Road(n, n+1, indexNumber);
	indexNumber++;
	//printf("Indexnumber:%d\n", indexNumber);
}
void banRoads()
{
	//time_t start, end;
	//start = time(NULL);
	for (int i = 0; i < k; i++) {
		int u, v, w, h1, h2;
		scanf("%d %d %d", &u, &v, &w);
		h1 = roadNumber(Road(u, v));
		h2 = roadNumber(Road(v, w));
		if (h1 < 0 || h2 < 0)
			continue;
		for(unsigned int j=0;j<roadGraph[h1].size();j++)
			if(roadGraph[h1][j].toNode==h2)
				roadGraph[h1][j].valid = false;
	}
	//end = time(NULL);
	//printf("Ban roads for %.2lf\n", difftime(end, start));
}
void showGraph()
{
	for (int i = 0; i <= n+1; i++) {
		printf("From vertex #%d:",i);
		for (unsigned int j = 0; j < originalGraph[i].size(); j++)
			printf("%d.%d\t", originalGraph[i][j], roadNumber(Road(i, originalGraph[i][j])));
		printf("\n");
	}
	for (int i = 0; i < indexNumber; i++) {
		printf("From road #%d which is %d->%d:", i,roadIndex[i].fromCity,roadIndex[i].toCity);
		for (unsigned int j = 0; j < roadGraph[i].size(); j++) {
			if (roadGraph[i][j].valid)
				printf("%d\t", roadGraph[i][j].toNode);
		}
		printf("\n");
	}
}
void buildRoadGraph()
{
	//time_t end, start;
	//start = time(NULL);
	for (int i = 0; i < MAXM; i++)
		roadGraph[i].clear();
	for (int i = 0; i <= n+1; i++) {
		for (unsigned int j = 0; j < originalGraph[i].size(); j++) {
			int tempRoadNumber = roadNumber(Road(i, originalGraph[i][j]));
			//printf("tempRoadNumber:%d\n", tempRoadNumber);
			int u = originalGraph[i][j];
			for (unsigned int v = 0; v < originalGraph[u].size(); v++) {
				int h = roadNumber(Road(u, originalGraph[u][v]));
				roadGraph[tempRoadNumber].push_back(CancellableVertex(h ));
			}
		}
	}
	//end = time(NULL);
	//printf("Index:%d\n", indexNumber);
	//printf("Build graph for %.2lf on %d %d %d\n", difftime(end, start), n, m, k);
}
int extractMin()
{
	int tempMin = INF;
	int tempMinIndex = -1;
	for (int i = 0; i < indexNumber; i++) {
		if (roadVertices[i].isValid&&roadVertices[i].weight<=tempMin) {
			tempMin = roadVertices[i].weight;
			tempMinIndex = i;
		}
	}
	if (tempMinIndex < 0)
		return tempMinIndex;
	roadVertices[tempMinIndex].isValid = false;
	return tempMinIndex;
}
int allMin;
vector<int > minRoute;
void bfs(int s)
{
	for (int i = 0; i < indexNumber; i++) {
		roadVertices[i].isValid = false;
		roadVertices[i].weight = INF;
		roadVertices[i].pi = -1;
	}
	roadVertices[s].isValid = true;
	roadVertices[s].weight = 0;
	queue<int > vertices;
	while (vertices.empty() == false)
		vertices.pop();
	vertices.push(s);
	while (vertices.empty() == false) {
		int u = vertices.front();
		vertices.pop();
		for (int i = 0; i < roadGraph[u].size(); i++) {
			if (roadGraph[u][i].valid) {
				int v = roadGraph[u][i].toNode;
				if (roadVertices[v].isValid == false) {
					roadVertices[v].isValid = true;
					roadVertices[v].weight = roadVertices[u].weight + 1;
					roadVertices[v].pi = u;
					vertices.push(v);
				}
			}
		}
	}
}
vector<int > routeNumbers;
void getRoute(int s, int t)
{
	if (roadVertices[t].pi == s) {
		routeNumbers.push_back(s);
		routeNumbers.push_back(t);
	}
	else if (roadVertices[t].pi < 0)
		routeNumbers.push_back(s);
	else {
		getRoute(s, roadVertices[t].pi);
		routeNumbers.push_back(t);
	}
}
void getMinRoute(int s, int t)
{
	routeNumbers.clear();
	getRoute(s, t);
	minRoute.clear();
	for (unsigned int i = 0; i < routeNumbers.size(); i++)
		minRoute.push_back(routeNumbers[i]);
}
void prepareData()
{
	FILE *output = fopen("dataPrepare.txt", "w");
	if (output == NULL) {
		perror("Can't open preparedata!\n");
		return;
	}
	srand(time(NULL));
	for (int i = 0; i < 20; i++) {
		int n, m, k;
		n = rand() % 3000;
		if (n < 2)
			n += 2;
		m = rand() % 20000;
		if (m < 1)
			m += 2;
		k = rand() % 100000;
		fprintf(output,"%d %d %d\n", n, m, k);
		for (int i = 0; i < m; i++) {
			int u, v;
			u = rand() % n;
			v = rand() % n;
			if (u == 0)
				u = 1;
			if (v == 0)
				v = 1;
			fprintf(output,"%d %d\n", u, v);
		}
		for (int i = 0; i < k; i++) {
			int u, v, w;
			u = rand() % n;
			v = rand() % n;
			w = rand() % n;
			if (u == 0)
				u = 1;
			if (v == 0)
				v = 1;
			if (w == 0)
				w = 1;
			fprintf(output, "%d %d %d\n", u, v, w);
		}
		fprintf(output, "\n");
	}
	fclose(output);
}
void solveOne(int s)
{
	bfs(s);
	int tempMin = INF;
	int h = roadNumber(Road(n , n+1));
	tempMin = roadVertices[h].weight;
	if (tempMin < allMin) {
		getMinRoute(s, h);
		allMin = tempMin;
	}
	//printf("For solving %d costs %.2lf s\n", s, difftime(end, start));
}
void solve()
{
	allMin = INF;
	int h = roadNumber(Road(0, 1));
？	solveOne(h);
	if (allMin == INF)
		printf("-1\n");
	else {
		printf("%d\n", minRoute.size()-2);
		for (unsigned int i = 0; i < minRoute.size()-1; i++) {
			printf("%d%c", roadIndex[minRoute[i]].toCity,i==minRoute.size()-2?'\n':' ');
		}
	}
}
int main()
{
	while (scanf("%d %d %d", &n, &m, &k) != EOF) {
		input();
		buildRoadGraph();
		banRoads();
		solve();
	}
	return 0;
}

今天又重新整理了一下，得到一份稍微清洁点的代码贴上。498ms，还是有点慢啊。另外为什么vjudge和上官网提交有性能差异呢？

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
using namespace std;
#define MAXN 3004
#define MAXM 40010
#define INF 0x3f3f3f3f
typedef struct road {
	int fromCity;
	int toCity;
	int NO;
	struct road() {}
	struct road(int u, int v) { fromCity = u; toCity = v; }
	struct road(int u, int v, int No) { fromCity = u; toCity = v; NO = No; }
	bool operator == (struct road r) { 
		return (fromCity == r.fromCity&&toCity == r.toCity);
	}
}Road;
typedef struct cancellableVertex {
	int toNode;
	bool valid;
	struct cancellableVertex(int to) { toNode = to; valid = true; }
}CancellableVertex;
typedef struct Vertex {
	int weight;
	bool isValid;
	int pi;
}Vertex;
int allRoads[MAXN][MAXN];
Road roadIndex[MAXM];
vector<int > originalGraph[MAXN];
vector<CancellableVertex > roadGraph[MAXM];
Vertex roadVertices[MAXM];
int n, m, k, indexNumber;
int roadNumber(Road r)
{
	return allRoads[r.fromCity][r.toCity];
}
void input()
{
	memset(allRoads, 0xff, sizeof(allRoads));
	for (int i = 0; i < MAXN; i++)
		originalGraph[i].clear();
	memset(roadIndex, 0xff, sizeof(roadIndex));
	indexNumber = 0;
	for (int i = 0; i < m; i++) {
		int u, v, h;
		scanf("%d %d", &u, &v);
		if (roadNumber(Road(u, v)) < 0) {
			allRoads[u][v] = indexNumber;
			roadIndex[indexNumber] = Road(u, v,indexNumber);
			indexNumber++;
			originalGraph[u].push_back(v);
		}
		if (roadNumber(Road(v, u)) < 0) {
			allRoads[v][u] = indexNumber;
			roadIndex[indexNumber] = Road(v, u,indexNumber);
			indexNumber++;
			originalGraph[v].push_back(u);
		}
	}
	originalGraph[0].push_back(1);
	originalGraph[n].push_back(n+1);
	allRoads[0][1] = indexNumber;
	roadIndex[indexNumber] = Road(0, 1, indexNumber);
	indexNumber++;
	allRoads[n][n+1] = indexNumber;
	roadIndex[indexNumber] = Road(n, n+1, indexNumber);
	indexNumber++;
}
void banRoads()
{
	for (int i = 0; i < k; i++) {
		int u, v, w, h1, h2;
		scanf("%d %d %d", &u, &v, &w);
		h1 = roadNumber(Road(u, v));
		h2 = roadNumber(Road(v, w));
		if (h1 < 0 || h2 < 0)
			continue;
		for(unsigned int j=0;j<roadGraph[h1].size();j++)
			if(roadGraph[h1][j].toNode==h2)
				roadGraph[h1][j].valid = false;
	}
}
void buildRoadGraph()
{
	for (int i = 0; i < MAXM; i++)
		roadGraph[i].clear();
	for (int i = 0; i <= n+1; i++) {
		for (unsigned int j = 0; j < originalGraph[i].size(); j++) {
			int tempRoadNumber = roadNumber(Road(i, originalGraph[i][j]));
			//printf("tempRoadNumber:%d\n", tempRoadNumber);
			int u = originalGraph[i][j];
			for (unsigned int v = 0; v < originalGraph[u].size(); v++) {
				int h = roadNumber(Road(u, originalGraph[u][v]));
				roadGraph[tempRoadNumber].push_back(CancellableVertex(h ));
			}
		}
	}
}
void bfs(int s)
{
	for (int i = 0; i < indexNumber; i++) {
		roadVertices[i].isValid = false;
		roadVertices[i].weight = INF;
		roadVertices[i].pi = -1;
	}
	roadVertices[s].isValid = true;
	roadVertices[s].weight = 0;
	queue<int > vertices;
	while (vertices.empty() == false)
		vertices.pop();
	vertices.push(s);
	while (vertices.empty() == false) {
		int u = vertices.front();
		vertices.pop();
		for (int i = 0; i < roadGraph[u].size(); i++) {
			if (roadGraph[u][i].valid) {
				int v = roadGraph[u][i].toNode;
				if (roadVertices[v].isValid == false) {
					roadVertices[v].isValid = true;
					roadVertices[v].weight = roadVertices[u].weight + 1;
					roadVertices[v].pi = u;
					vertices.push(v);
				}
			}
		}
	}
}
vector<int > routeNumbers;
void getRoute(int s, int t)
{
	if (roadVertices[t].pi == s) {
		routeNumbers.push_back(s);
		routeNumbers.push_back(t);
	}
	else if (roadVertices[t].pi < 0)
		routeNumbers.push_back(s);
	else {
		getRoute(s, roadVertices[t].pi);
		routeNumbers.push_back(t);
	}
}
void solve()
{
	int h = roadNumber(Road(0, 1));
	bfs(h);
	if (roadVertices[indexNumber-1].weight == INF)
		printf("-1\n");
	else {
		routeNumbers.clear();
		getRoute(h, indexNumber - 1);
		printf("%d\n", routeNumbers.size()-2);
		for (unsigned int i = 0; i < routeNumbers.size()-1; i++) {
			printf("%d%c", roadIndex[routeNumbers[i]].toCity,i==routeNumbers.size()-2?'\n':' ');
		}
	}
}
int main()
{
	while (scanf("%d %d %d", &n, &m, &k) != EOF) {
		input();
		buildRoadGraph();
		banRoads();
		solve();
	}
	return 0;
}

ILIKUSUNYI
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CodeForces:CodeForces解决方案
04-19
CodeForces解决方案 Codeforces是一个托管竞争性编程竞赛的网站。 它是由来自ITMO大学的一组有竞争力的程序员维护的，由Mikhail Mirzayanov领导。 自2013年以来，Codeforces声称在活跃参赛者方面超过Topcoder。 截至...
codeforces59E Shortest Path （bfs）
TelmaZzzz的博客
04-30 251
题解： 大致题意为给定3e3的无向图，已经给定1e5组非法行走路线（ai，bi，ci），问最少走几条路从1走到n，并输出路线 由于点只有3e3，所以可以记录前驱是pre，当前是x为小节点，是否跑过，来跑一遍bfs 这样就不会出现队列元素过多的情况出现。 代码： #include <map> #include <set> #include <ctime> #inc...
Codeforces - Shortest Path
青烟绕指柔的博客
08-24 221
题目链接：Codeforces - Shortest Path 跑BFS的时候，对每个点记录是从哪个点过来的，然后就变成快速check3个点是否合法了。 哈希即可。 AC代码： #pragma GCC optimize("-Ofast","-funroll-all-loops") #include<bits/stdc++.h> //#define int long long using namespace std; const int N=3e3+10; int n,m,k,d[N][N],
Codeforces 590E
mayaohua
12-10 331
终于会证明dilworth定理了。。。 定义一个字符串a≤ba\leq ba≤b当且仅当aaa是bbb的子串，显然≤\leq≤是一种偏序关系。那么问题转化为求出最长反链。 首先需要知道字符串间的偏序关系。将所有字符串建出AC自动机并求出fail树，就容易知道每个字符串有哪些字符串为其子串。不过暴力做需要跳整条fail链，注意到子串关系有传递性，于是我们只记录每个点fail链上能跳到的最近的字符串，...
[codeforces 938G]Shortest Path Queries
WorldWide_D的博客
03-01 790
题目大意给定一个n个点m条边的无向联通简单图，边有边权。接下来有q次操作，操作有三种： 1. 添加一条边，保证添加后仍是简单图 2. 删除一条边，保证删除后仍是联通图 3. 给定x,y，求所有x到y的路径中所有边权异或和最小值（一条边经过多次算多次） n,m,q≤200000 边权<230<2^{30}分析首先我们联想到CF另一道题845G，这题没有前两个操作，只询问1到n的答案。 那道
CodeForces 59E Shortest Path 用边跑最短路
九野的博客
02-07 1647
题目链接：点击打开链接 题意： 给定n个点m条边的无向图，d个限制条件。 下面m行给出边 下面d行给出限制条件。 找出一条 1->n的路径。 每个限制条件3个数 a b c 表示这3个点不能连续走，即路径上不能存在 ···abc···或者···cba··· 输出这样的最短路径长度以及具体路径。 思路： 因为是3个点不能连续走，所以我们用边来跑最短路即可，这样就变成2条边不能连续走
codeforces enhancer 1.1.2
10-24
使用于Google Chrome的Codeforces Enhancer 1.1.2插件安装包。 版本：codeforces enhancer 1.1.2 使用浏览器：Google Chrome
CodeforcesPP:Codeforces扩展包
05-06
Codeforces ++ Codeforces扩展包 相关连结 特征 “显示标签”按钮 导航栏下拉菜单使导航更加轻松 mashup / gym问题上的“ Google It”按钮 教程弹出按钮 自定义样式 自动更新排名页面 键盘快捷键（请参见下文） 在...
CodeForces – 1327D Infinite Path(图论综合)
01-20
然后抛出Infinite Path的定义：对于某个 i ，p[ i ] , p[ p[ i ] ] , p[ p[ p[ i ] ] ] 无限嵌套下去，且每个位置的颜色相同，即 c[ i ] = c[ p[ i ] ] = c[ p[ p[ i ] ] ] = c[ p[ p[ p[ i ] ] ] ] 等等等等 ...
Codeforces:解决Codeforce问题的方法
05-01
解决问题的方法教育Codeforces回合101 - 2/6 常规托架顺序-接受红色和蓝色-接受Codeforces回合＃686（Div.3） 2/6 特殊排列-接受唯一出价拍卖-接受序列转换-接受编号成序列-接受Codeforces回合＃685（分区2） 2/7 减...
codeforce266D 最短路
ijbuhv的专栏
05-16 706
//给你一个无向连通图,找一个点使得它到这个图最短路中最大的距离最短 //可以遍历所有边，对于每条边有的连个顶点u,v //可以通过这两个点将这个图分左边，u-v边,右边三个部分 //但是哪些点分在左边，哪些点分在右边，如果暴力所有情况显然会超时 //用一个二维数组存入所有点到u,v两个点的最短路 //将其排序，对于a[i].u >=a[j].u ,a[i].v >= a[j].v 的点
[codeforces870F] Paths
WorldWide_D的博客
10-30 594
题目大意对于一个n个节点的图，节点编号为1到n，对于两个节点u,v，如果它们的gcd大于1，那么u与v之间有一条长度为1的边。 给定n，求节点两两之间距离之和（不连通则距离视为0）n≤10710^7分析首先容易发现，两个端点如果有一个编号为1或为大于n2\frac{n}{2}的质数的点，那么这两点间一定没有路径。 接着两两间有路径的点对分以下几种情况： 1. 编号相同，距离为0 2. gcd
算法设计与分析 递归与分治 回溯算法 分支限界 动态规划 贪心算法 近拟算法
Fish1112的专栏
06-24 1666
<br /> <!-- /* Font Definitions */ @font-face {font-family:宋体; panose-1:2 1 6 0 3 1 1 1 1 1; mso-font-alt:SimSun; mso-font-charset:134; mso-generic-font-family:auto; mso-font-pitch:variable; mso-font-signature:3 135135232 16 0 262145 0;}
高级色系PPT11.pptx
05-08
高级色系PPT11.pptx
node-v7.9.0-linux-x86.tar.xz
05-08
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提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于tensorflow的的cnn卷积神经网络的图像识别分类
05-08
【作品名称】：基于tensorflow的的cnn卷积神经网络的图像识别分类 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
### 数据分析概念、使用技巧、优缺点的文章
05-08
数据分析是指通过收集、清洗、处理和解释数据，以发现其中的模式、趋势和关联，从而提供决策支持或洞察见解的过程。它在各行各业中都扮演着至关重要的角色，从市场营销到科学研究，从金融领域到医疗保健，都有广泛的应用。
对微信帐单进行数据分析
05-08
#pip install pandas -i https://mirrors.aliyun.com/pypi/simple #安装pandas处理数据模块 #pip install xlwt -i https://mirrors.aliyun.com/pypi/simple #安装excel模块 #pip install openpyxl #从微信导出对帐帐单 import pandas as pd #引入pandas，重命名为pd,Python3.9.10版本的Pandas无法兼容低版本的xls import numpy as np #导入均值模块 #从第17行读取csv格式的帐单 df = pd.read_csv('微信支付账单(20230101-20230401).csv',header=16) #分析数据 ...... #将分析数据另存为out.xlsx ..... #进行交易进间分析 ...... #统计交易对方 ...... #将结果保存到excel ..... writer.close()
node-v7.2.0-sunos-x86.tar.xz
最新发布
05-08
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提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
codeforces
10-01
Codeforces是一个著名的在线编程竞赛平台，提供了大量的算法和编程题目供程序员刷题。在你提供的引用中，这些引用包含了一些Codeforces的比赛和问题的名称。其中，CodeForces 984A，CodeForces 1132B，CodeForces ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值