1.日志统计

题目

小明维护着一个程序员论坛。现在他收集了一份”点赞”日志，日志共有 N 行。

其中每一行的格式是：

ts id
表示在 ts 时刻编号 id 的帖子收到一个”赞”。

现在小明想统计有哪些帖子曾经是”热帖”。

如果一个帖子曾在任意一个长度为 D 的时间段内收到不少于 K 个赞，小明就认为这个帖子曾是”热帖”。

具体来说，如果存在某个时刻 T 满足该帖在 [T,T+D) 这段时间内(注意是左闭右开区间)收到不少于 K 个赞，该帖就曾是”热帖”。

给定日志，请你帮助小明统计出所有曾是”热帖”的帖子编号。

输入格式

第一行包含三个整数 N,D,K。

以下 N 行每行一条日志，包含两个整数 ts 和 id。

输出格式

按从小到大的顺序输出热帖 id。

每个 id 占一行。

数据范围

1≤K≤N≤105,
0≤ts,id≤105,
1≤D≤10000

输入样例：

7 10 2
0 1
0 10
10 10
10 1
9 1
100 3
100 3

输出样例：

1
3

分析

双指针算法
每次判定一个长度为D的区间，然后两边分别移动
判定是否满足点赞数为K

代码

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>#define x first
#define y second using namespace std;typedef pair<int,int> PII;const int N = 100010;int n,d,k;
PII logs[N];
int cnt[N];
bool st[N];int main()
{scanf("%d%d%d",&n,&d,&k);for(int i = 0;i < n;i++) scanf("%d%d",&logs[i].x,&logs[i].y);sort(logs,logs + n);for(int i = 0,j = 0;i < n;i++){int id = logs[i].y;cnt[id]++;while(logs[i].x - logs[j].x >= d){cnt[logs[j].y]--;  //减去开头,下一次循环的时候是嘉善结尾j++;}if(cnt[id] >= k) st[id] = true;}for(int i = 0;i < 100000;i++)if(st[i])printf("%d\n",i);return 0;
}

2. 献给阿尔吉侬的花束

题目

阿尔吉侬是一只聪明又慵懒的小白鼠，它最擅长的就是走各种各样的迷宫。

今天它要挑战一个非常大的迷宫，研究员们为了鼓励阿尔吉侬尽快到达终点，就在终点放了一块阿尔吉侬最喜欢的奶酪。

现在研究员们想知道，如果阿尔吉侬足够聪明，它最少需要多少时间就能吃到奶酪。

迷宫用一个 R×C 的字符矩阵来表示。

字符 S 表示阿尔吉侬所在的位置，字符 E 表示奶酪所在的位置，字符 # 表示墙壁，字符 . 表示可以通行。

阿尔吉侬在 1 个单位时间内可以从当前的位置走到它上下左右四个方向上的任意一个位置，但不能走出地图边界。

输入格式

第一行是一个正整数 T，表示一共有 T 组数据。

每一组数据的第一行包含了两个用空格分开的正整数 R 和 C，表示地图是一个 R×C 的矩阵。

接下来的 R 行描述了地图的具体内容，每一行包含了 C 个字符。字符含义如题目描述中所述。保证有且仅有一个 S 和 E。

输出格式

对于每一组数据，输出阿尔吉侬吃到奶酪的最少单位时间。

若阿尔吉侬无法吃到奶酪，则输出“oop!”（只输出引号里面的内容，不输出引号）。

每组数据的输出结果占一行。

数据范围

1<T≤10,
2≤R,C≤200

输入样例：

3
3 4
.S…
###.
…E.
3 4
.S…
.E…
…
3 4
.S…

…E.

输出样例：

5
1
oop!

分析

bfs和入队操作

这样一串的操作就适合队列的操作

代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>#define x first
#define y secondusing namespace std;typedef pair<int, int> PII;const int N = 210;int n, m;
char g[N][N];
int dist[N][N];int bfs(PII start, PII end)
{queue<PII> q;memset(dist, -1, sizeof dist);dist[start.x][start.y] = 0;q.push(start);int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};while (q.size()){auto t = q.front();q.pop();for (int i = 0; i < 4; i ++ ){int x = t.x + dx[i], y = t.y + dy[i];if (x < 0 || x >= n || y < 0 || y >= m) continue;  // 出界if (g[x][y] == '#') continue;  // 障碍物if (dist[x][y] != -1) continue;  // 之前已经遍历过dist[x][y] = dist[t.x][t.y] + 1;if (end == make_pair(x, y)) return dist[x][y];q.push({x, y});}}return -1;
}int main()
{int T;scanf("%d", &T);while (T -- ){scanf("%d%d", &n, &m);for (int i = 0; i < n; i ++ ) scanf("%s", g[i]);PII start, end;for (int i = 0; i < n; i ++ )for (int j = 0; j < m; j ++ )if (g[i][j] == 'S') start = {i, j};else if (g[i][j] == 'E') end = {i, j};int distance = bfs(start, end);if (distance == -1) puts("oop!");else printf("%d\n", distance);}return 0;
}

3.红与黑

题目

有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。

你站在其中一块黑色的瓷砖上，只能向相邻（上下左右四个方向）的黑色瓷砖移动。

请写一个程序，计算你总共能够到达多少块黑色的瓷砖。

输入格式

输入包括多个数据集合。

每个数据集合的第一行是两个整数 W 和 H，分别表示 x 方向和 y 方向瓷砖的数量。

在接下来的 H 行中，每行包括 W 个字符。每个字符表示一块瓷砖的颜色，规则如下

1）‘.’：黑色的瓷砖；
2）‘#’：白色的瓷砖；
3）‘@’：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每个数据集合中唯一出现一次。

当在一行中读入的是两个零时，表示输入结束。

输出格式

对每个数据集合，分别输出一行，显示你从初始位置出发能到达的瓷砖数(记数时包括初始位置的瓷砖)。

数据范围

1≤W,H≤20

输入样例：

6 9
…#.
…#
…
…
…
…
…
#@…#
.#…#.
0 0

输出样例：

45

分析

dfs

代码

/*
1.输入两个整数 W 和 H，分别表示 x 方向和 y 方向瓷砖的数量
2.找到开始的点
3.搜索函数黑色 +  1红色  continue被遍历过   continue
4.输出
*/#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>using namespace std;const int N = 25;
char g[N][N];  //原数组
bool st[N][N];  //判定数组
int n,m;int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};int dfs(int x,int y)
{int cnt = 1;st[x][y] = true;for(int i = 0;i < 4;i++){int a = x + dx[i],b = y + dy[i];if (a < 0 || a >= n || b < 0 || b >= m) continue;if (g[a][b] != '.') continue;if (st[a][b]) continue;cnt += dfs(a,b);}return cnt;
}int main()
{while(cin >> m >> n,n || m){for(int i = 0;i < n;i++) cin >> g[i];int x,y;for(int i = 0;i < n;i++){for(int j = 0;j < m;j++){if(g[i][j] == '@'){x = i;y = j;}}}memset(st,0,sizeof st);  //清空判定数组cout << dfs(x,y) << endl;}return 0;
}

4.交换瓶子

题目

有 N 个瓶子，编号 1∼N，放在架子上。

比如有 5 个瓶子：

2 1 3 5 4
要求每次拿起 2 个瓶子，交换它们的位置。

经过若干次后，使得瓶子的序号为：

1 2 3 4 5
对于这么简单的情况，显然，至少需要交换 2 次就可以复位。

如果瓶子更多呢？你可以通过编程来解决。

输入格式

第一行包含一个整数 N，表示瓶子数量。

第二行包含 N 个整数，表示瓶子目前的排列状况。

输出格式

输出一个正整数，表示至少交换多少次，才能完成排序。

数据范围

1≤N≤10000,

输入样例1：

5
3 1 2 5 4

输出样例1：

3

输入样例2：

5
5 4 3 2 1

输出样例2：

2

分析

连边，然后算环的个数 ，总数减去环的个数就是 交换的 次数

why？

代码

#include<iostream>
using namespace std;const int N = 10010;int b[N];
bool st[N];
int cnt;
int  n;int main()
{cin >> n;for(int i = 1;i  <= n;i++) cin >> b[i];//算出环的个数for(int i = 1;i <= n;i++){if(!st[i]){cnt++;for(int j = i;!st[j];j = b[j])  //把相关的全部标记st[j] = true;}}cout << n - cnt << endl;return 0;}

5. 完全二叉树的权值

题目

给定一棵包含 N 个节点的完全二叉树，树上每个节点都有一个权值，按从上到下、从左到右的顺序依次是 A1,A2,⋅⋅⋅AN，如下图所示：

现在小明要把相同深度的节点的权值加在一起，他想知道哪个深度的节点权值之和最大？

如果有多个深度的权值和同为最大，请你输出其中最小的深度。

注：根的深度是 1。

输入格式

第一行包含一个整数 N。

第二行包含 N 个整数 A1,A2,⋅⋅⋅AN。

输出格式

输出一个整数代表答案。

数据范围

1≤N≤105,
−105≤Ai≤105

输入样例：

7
1 6 5 4 3 2 1

输出样例：

2

分析

/*
1.输入N，输入序列s[]
2.遍历每一层
3.每一层算出多少来，更新最大值和此时的深度
4.输出
*/#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;typedef long long LL;const int N = 100010;
int s[N];
LL maxs = -1e18;
LL x;
int maxd;int main()
{int n;cin >> n;for(int i = 1;i <= n;i++)  cin >> s[i];for(int d = 1,i = 1;i <= n;d++,i *= 2) //d  层数  i  每层的第一个下标{x = 0;for(int j = i;j < i * 2 && j <= n;j++)  //x 此时求的这一行的和 {x += s[j];}if(x > maxs){maxd = d;maxs = x;}}cout << maxd << endl;return 0;
}

6. 地牢大师

题目

你现在被困在一个三维地牢中，需要找到最快脱离的出路！

地牢由若干个单位立方体组成，其中部分不含岩石障碍可以直接通过，部分包含岩石障碍无法通过。

向北，向南，向东，向西，向上或向下移动一个单元距离均需要一分钟。

你不能沿对角线移动，迷宫边界都是坚硬的岩石，你不能走出边界范围。

请问，你有可能逃脱吗？

如果可以，需要多长时间？

输入格式

输入包含多组测试数据。

每组数据第一行包含三个整数 L,R,C 分别表示地牢层数，以及每一层地牢的行数和列数。

接下来是 L 个 R 行 C 列的字符矩阵，用来表示每一层地牢的具体状况。

每个字符用来描述一个地牢单元的具体状况。

其中, 充满岩石障碍的单元格用”#”表示，不含障碍的空单元格用”.”表示，你的起始位置用”S”表示，终点用”E”表示。

每一个字符矩阵后面都会包含一个空行。

当输入一行为”0 0 0”时，表示输入终止。

输出格式

每组数据输出一个结果，每个结果占一行。

如果能够逃脱地牢，则输出”Escaped in x minute(s).”，其中X为逃脱所需最短时间。

如果不能逃脱地牢，则输出”Trapped!”。

数据范围

1≤L,R,C≤100

输入样例：

3 4 5
S…
.###.
.##…
###.#

##.##
##…

#.###
####E

1 3 3
S##
#E#

0 0 0

输出样例：

Escaped in 11 minute(s).
Trapped!

分析

BFS

代码

/*
1.输入 L  R  C
2.输入地牢矩阵
3.BFS走一遍从起点开始遍历6个方向出界  continue遍历过  continue墙壁 continue
4.输出：如果能够逃脱地牢，则输出”Escaped in x minute(s).”，其中X为逃脱所需最短时间。如果不能逃脱地牢，则输出”Trapped!”。
*/ #include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;const int N = 110;struct Point
{int x,y,z;
};int L,R,C;
char g[N][N][N];
Point q[N * N * N];   //这样的一串东西
int dist[N][N][N];  //代表几分钟，也就是几步了int dx[6] = {1,-1,0,0,0,0};
int dy[6] = {0,0,1,-1,0,0};
int dz[6] = {0,0,0,0,1,-1};int bfs(Point start,Point end)
{//一串的操作适合放到队列里面int hh = 0,tt = 0;memset(dist,-1,sizeof dist);q[0] = start;dist[start.x][start.y][start.z] = 0;while(hh <= tt){auto t = q[hh++];  //队头for(int i = 0;i < 6;i++) //6个方向{int x = t.x + dx[i];int y = t.y + dy[i];int z = t.z + dz[i];//continueif(x < 0 || x >= L || y < 0 || y >= R || z < 0 || z >= C) continue; //出界if(g[x][y][z] == '#') continue;if(dist[x][y][z] != -1) continue;dist[x][y][z] = dist[t.x][t.y][t.z] + 1;//正确结果if(g[x][y][z] == 'E') return dist[x][y][z];q[++tt] = {x,y,z};  //满足条件，入队}}return -1;
}int main()
{while(scanf("%d%d%d",&L,&R,&C),L || R || C){Point start,end;for(int i = 0;i < L;i++){for(int j = 0;j < R;j++){scanf("%s",g[i][j]);//找到开始点和终点for(int k = 0;k < C;k++){char c = g[i][j][k];if(c == 'S') start = {i,j,k};else if(c == 'E') end = {i,j,k};}}}int distance = bfs(start,end);if(distance == -1) printf("Trapped!\n");else printf("Escaped in %d minute(s).\n",distance);}return 0;
}

7. 全球变暖

题目

你有一张某海域 N×N 像素的照片，”.”表示海洋、”#”表示陆地，如下所示：

…
.##…
.##…
…##.
…####.
…###.
…
其中”上下左右”四个方向上连在一起的一片陆地组成一座岛屿，例如上图就有 2 座岛屿。

由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。

具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。

例如上图中的海域未来会变成如下样子：

…
…
…
…
…#…
…
…
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。

输入格式

第一行包含一个整数N。

以下 N 行 N 列，包含一个由字符”#”和”.”构成的 N×N 字符矩阵，代表一张海域照片，”#”表示陆地，”.”表示海洋。

照片保证第 1 行、第 1 列、第 N 行、第 N 列的像素都是海洋。

输出格式

一个整数表示答案。

数据范围

1≤N≤1000

输入样例1：

7
…
.##…
.##…
…##.
…####.
…###.
…

输出样例1：

1

输入样例2：

9
…
.##.##…
.#####…
.##.##…
…
.##.#…
.#.###…
.#…#…
…

输出样例2：

1

分析

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>#define x first
#define y secondusing namespace std;typedef pair<int,int> PII;int n;
const int N = 1010;
char g[N][N];  //存放地图
bool st[N][N];
PII q[N * N];int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};void bfs(int sx,int sy,int &total,int &bound)   //注意这里的total和bound  是指针传输
{//队列的操作int hh = 0,tt = 0;q[0] = {sx,sy};  //入队while(hh <= tt)  //队列不为空{PII t = q[hh ++];bool is_bound = false;total++;  //每放进来一个，total就增加1for(int i = 0;i < 4;i++)  //遍历四个方向{int x = t.x + dx[i],y = t.y + dy[i];if(x  < 0 || x >= n || y < 0 || y >= n) continue;  //出界if(st[x][y]) continue;  //遍历过if(g[x][y] == '.')  //如果周边有海洋{is_bound = true;continue;}q[++ tt] = {x,y};st[x][y] = true;}if(is_bound) bound++;}
}int main()
{cin >> n;for(int i = 0;i < n;i++)    scanf("%s",g[i]);int cnt = 0;  //被淹没的数量for(int i = 0;i < n;i++){for(int j = 0;j < n;j++){if(!st[i][j] && g[i][j] == '#')  //没有遍历过，并且是陆地{int total  = 0,bound = 0;  //total  整个岛的块数  bound  边界的块数  bfs(i,j,total,bound);if(bound == total) cnt++;}}}cout << cnt << endl;return 0;
}

8. 大臣的旅费

题目

很久以前，T王国空前繁荣。

为了更好地管理国家，王国修建了大量的快速路，用于连接首都和王国内的各大城市。

为节省经费，T国的大臣们经过思考，制定了一套优秀的修建方案，使得任何一个大城市都能从首都直接或者通过其他大城市间接到达。

同时，如果不重复经过大城市，从首都到达每个大城市的方案都是唯一的。

J是T国重要大臣，他巡查于各大城市之间，体察民情。

所以，从一个城市马不停蹄地到另一个城市成了J最常做的事情。

他有一个钱袋，用于存放往来城市间的路费。

聪明的J发现，如果不在某个城市停下来修整，在连续行进过程中，他所花的路费与他已走过的距离有关，在走第x千米到第x+1千米这一千米中（x是整数），他花费的路费是x+10这么多。也就是说走1千米花费11，走2千米要花费23。

J大臣想知道：他从某一个城市出发，中间不休息，到达另一个城市，所有可能花费的路费中最多是多少呢？

输入格式

输入的第一行包含一个整数 n，表示包括首都在内的T王国的城市数。

城市从 1 开始依次编号，1 号城市为首都。

接下来 n−1 行，描述T国的高速路（T国的高速路一定是 n−1 条）。

每行三个整数 Pi,Qi,Di，表示城市 Pi 和城市 Qi 之间有一条双向高速路，长度为 Di 千米。

输出格式

输出一个整数，表示大臣J最多花费的路费是多少。

数据范围

1≤n≤105,
1≤Pi,Qi≤n,
1≤Di≤1000

输入样例：

5
1 2 2
1 3 1
2 4 5
2 5 4

输出样例：

135

分析

求最长的 直径

代码

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>using namespace std;const int N = 100010;struct Edge
{int id,w;
};
vector<Edge> h[N];
int dist[N];int n;void dfs(int u,int father,int distance)
{dist[u] = distance;for(auto node : h[u])  //遍历附近的每一个节点{if(node.id != father)  //防止重复遍历自己   dfs(node.id,u,distance + node.w);}
}int main()
{scanf("%d",&n);for(int i = 0;i < n - 1;i++){int a,b,c;scanf("%d%d%d",&a,&b,&c);h[a].push_back({b,c});   //把每一个点之间的关系建立起来h[b].push_back({a,c});}dfs(1,-1,0);  //第一次的遍历   找出最长的那个int u = 1;for(int i = 0;i <= n;i++)if(dist[i] > dist[u])u = i;dfs(u,-1,0);for(int i = 0;i <= n;i++)if(dist[i] > dist[u])u = i;int s = dist[u];printf("%lld",s  * 10 + s * (s + 1ll) / 2);return 0;}

9. 单链表

题目

实现一个单链表，链表初始为空，支持三种操作：

(1) 向链表头插入一个数；

(2) 删除第k个插入的数后面的数；

(3) 在第k个插入的数后插入一个数

现在要对该链表进行M次操作，进行完所有操作后，从头到尾输出整个链表。

注意:题目中第k个插入的数并不是指当前链表的第k个数。例如操作过程中一共插入了n个数，则按照插入的时间顺序，这n个数依次为：第1个插入的数，第2个插入的数，…第n个插入的数。

输入格式

第一行包含整数M，表示操作次数。

接下来M行，每行包含一个操作命令，操作命令可能为以下几种：

(1) “H x”，表示向链表头插入一个数x。

(2) “D k”，表示删除第k个输入的数后面的数（当k为0时，表示删除头结点）。

(3) “I k x”，表示在第k个输入的数后面插入一个数x（此操作中k均大于0）。

输出格式

共一行，将整个链表从头到尾输出。

数据范围

1≤M≤100000
所有操作保证合法。

输入样例：

10
H 9
I 1 1
D 1
D 0
H 6
I 3 6
I 4 5
I 4 5
I 3 4
D 6

输出样例：

6 4 6 5

分析

代码

/*
1.输入M  操作次数
2.输入M行(1) “H x”，表示向链表头插入一个数x。(2) “D k”，表示删除第k个输入的数后面的数（当k为0时，表示删除头结点）。(3) “I k x”，表示在第k个输入的数后面插入一个数x（此操作中k均大于0）。
3.分别操作4.输出链表
*/#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>using namespace std;const int N = 100010;
int head,e[N],ne[N],idx;  //idx  现在的节点指针
int M;void init()
{head = -1;
}void add_to_head(int x)
{e[idx] = x,ne[idx] = head,head = idx ++;
}void remove(int k)
{ne[k] = ne[ne[k]];
}void add_k(int k,int x)
{e[idx] = x,ne[idx] = ne[k],ne[k] = idx++;
}int main()
{init();cin >> M;while(M--){char op;int k,x;cin >> op;if(op == 'H')  //向链表头插入一个数x{cin >> x;add_to_head(x);}else if(op == 'D'){cin >> k;if(!k) head = ne[head];  //删除头节点else remove(k - 1);}else if(op == 'I'){cin >> k >> x;add_k(k - 1,x);}}for(int i = head;i != -1;i = ne[i]) cout << e[i] << ' ';puts("");return 0;
}

算法学习——双指针，BFS，图论相关推荐

1. 广度优先算法学习（BFS）

   前言 人生如逆旅,我亦是行人.----苏轼<临江仙·送钱穆父> 广度优先搜索介绍 广度优先搜索算法(又称宽度优先搜索)是最简便的图的搜索算法之一,这一算法也是很多重要的图的算法的原型. D ...

2. 七桥问题c语言程序数据结构,数据结构与算法学习——图论

   什么是图? 在计算机程序设计中,图结构也是一种非常常见的数据结构 但是图论其实是一个非常大的话题 图结构是一种与树结构有些相似的数据结构 图论是数学的一个分支,并且在数学概念上,树是图的一种 它以图为 ...

3. 数据结构与算法学习⑤(BFS和DFS 贪心算法 二分查找)

   数据结构与算法学习⑤ 数据结构与算法学习⑤ 1.BFS和DFS 1.1.深度优先搜索算法 1.2.广度优先搜索算法 面试实战 102. 二叉树的层序遍历 104. 二叉树的最大深度 515. 在每个树 ...

4. 数学建模图论算法学习总结

   数学建模图论算法学习总结 图论基本知识 B站视频: https://www.bilibili.com/video/av18374161/?p=35 https://www.bilibili.com/v ...

5. 算法学习 （门徒计划）3-3 深搜（DFS）与广搜（BFS）及经典问题 学习笔记

   算法学习 (门徒计划)3-3 深搜(DFS)与广搜(BFS)及经典问题 学习笔记 前言 深搜与广搜 搜索的核心概念 问题求解树 搜索剪枝和优化 问题求解树的状态 对比深搜与广搜 DFS-深度(deep ...

6. 基础算法学习大纲（附加yxc大佬算法模板）

   基础算法学习大纲总结 学习算法路线 1.基础算法 模板 1.排序 2.二分 3.高精度 4.前缀和与差分 5.双指针算法 6.位运算 7.离散化 8.区间合并 2.数据结构 模板 1.链表与邻接链表( ...

7. 原创 | 初学者友好！最全算法学习资源汇总（附链接）

   在计算机发展飞速的今天,也许有人会问,"今天计算机这么快,算法还重要吗?"其实永远不会有太快的计算机,因为我们总会想出新的应用.虽然在摩尔定律的作用下,计算机的计算能力每年都在飞快 ...

8. 计算机专业考研复试上机算法学习

   计算机专业考研复试上机算法学习 这篇博客是博主在准备可能到来的线下上机复试基于王道机试指南的学习,将各道习题链接和代码记录下来,这篇博客权且当个记录. 文章目录 计算机专业考研复试上机算法学习 1.S ...

9. 超级干货 ：最全算法学习资源汇总（附链接）

   在计算机发展飞速的今天,也许有人会问,"今天计算机这么快,算法还重要吗?"其实永远不会有太快的计算机,因为我们总会想出新的应用.虽然在摩尔定律的作用下,计算机的计算能力每年都在飞快 ...

最新文章

1. 2.javascript之缓存 localStorage 和sessionStorage之间的区别
2. R语言ggplot2可视化并添加特定区间的回归线、R原生plot函数可视化并添加特定区间的回归线：Add Regression Line Between Certain Limits
3. 一生一世高圆圆经典台词
4. php如何定义和使用常量,如何在PHP中定义和使用常量
5. 【转】FireFox与IE js脚本差异 小结
6. ssm java上传图片预览_ssm文件上传_上传图片
7. python输出今天时间_Python获取并输出当前日期时间
8. 计算机等级考试四级--软件工程
9. windows自带黑体_window自带字体
10. 使用预计算实时全局光照优化照明-优化实时光照贴图
11. Android 10 SystemUI中Android.bp文件中集成第三方JAR包或者so文件的方法
12. 《基于Cortex-M4的虚拟机制作与测试》课程设计 结题报告
13. 7、快速更改subclass颜色
14. 键盘各个键所对应的键值
15. html中鼠标移动在标签上出现小手形状
16. 解决：jar解压缩之后，图标变白的问题
17. 计算机类大学生竞赛经验分享
18. 9.27 股票盈利计划 只做超短线 利益最大化
19. 算法基础: 什么是红黑树?
20. Win10远程桌面连接不上Win7的桌面的一次奇葩经历

热门文章

1. SVN中的结果代码是什么意思？
2. 一个快乐网管的经验谈，教你怎样做快乐网管（转）
3. 专家系统/模糊理论/神经网络/遗传算法相关基础知识
4. 一个工作薄有多少工作表，每个工作表有多少行和多少列
5. Vue介绍以及练手案例——音乐播放器（搜索音乐、听歌、看评论、看mv等）（持续更新）
6. Chrome使用独立显卡开启WebGPU
7. 一步步教你使用Proguard混淆Java源代码
8. 南昌大学计算机学硕报考人数,2021考研：谨慎报考这十所报考人数爆棚的高校...
9. 互联网思维不重要，重要的是玩法变了
10. Python的过去和现在