HerdingCat
HerdingCat

数据结构---图

图

DFS和BFS是两种用途极广的工具。


哥尼斯堡的“七桥问题”   (25分)

哥尼斯堡是位于普累格河上的一座城市，它包含两个岛屿及连接它们的七座桥，如下图所示。

可否走过这样的七座桥，而且每桥只走过一次？瑞士数学家欧拉(Leonhard Euler，1707—1783)最终解决了这个问题，并由此创立了拓扑学。

这个问题如今可以描述为判断欧拉回路是否存在的问题。欧拉回路是指不令笔离开纸面，可画过图中每条边仅一次，且可以回到起点的一条回路。现给定一个无向图，问是否存在欧拉回路？

输入格式:

输入第一行给出两个正整数，分别是节点数NNN (1≤N≤10001\le N\le 10001≤N≤1000)和边数MMM；随后的MMM行对应MMM条边，每行给出一对正整数，分别是该条边直接连通的两个节点的编号（节点从1到NNN编号）。

输出格式:

若欧拉回路存在则输出1，否则输出0。

输入样例1:

6 10
1 2
2 3
3 1
4 5
5 6
6 4
1 4
1 6
3 4
3 6

输出样例1:

1

输入样例2:

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

输出样例2:

0

解题思路：

按照欧拉回路的判断方法

1）对于无向图是否联通，采用并查集判断

2）此外还要判断顶点度数

提交代码：

编译器：g++

#include 
#include 
using namespace std;
const int MAXN = 1002;
int root[MAXN];
int d[MAXN];
int Find(int x);
int main()
{
	int n, m;
	int u, v;
	scanf("%d%d", &n, &m);
	int tmpn = n;
	for(int i = 0; i <= n; ++i)
		root[i] = i;
	for(int i = 0; i < m; ++i)
	{
		scanf("%d%d", &u, &v);
		d[u]++, d[v]++;
		int x = Find(u);
		int y = Find(v);
		if(x != y)
		{
			root[y] = x;
			tmpn--;
		} 
	}
	if(tmpn != 1) printf("0\n"); //是否最后合并为一个组
	else
	{
		int i;
		for(i = 1; i <= n; ++i)
			if(d[i]%2) break; //是否全是偶数度数
		if(i > n) printf("1\n");
		else printf("0\n");
	}
	return 0;
}
int Find(int x)
{
	if(x != root[x])
		root[x] = Find(root[x]);
	return root[x];
}

地下迷宫探索   (30分)

地道战是在抗日战争时期，在华北平原上抗日军民利用地道打击日本侵略者的作战方式。地道网是房连房、街连街、村连村的地下工事，如下图所示。

我们在回顾前辈们艰苦卓绝的战争生活的同时，真心钦佩他们的聪明才智。在现在和平发展的年代，对多数人来说，探索地下通道或许只是一种娱乐或者益智的游戏。本实验案例以探索地下通道迷宫作为内容。

假设有一个地下通道迷宫，它的通道都是直的，而通道所有交叉点（包括通道的端点）上都有一盏灯和一个开关。请问你如何从某个起点开始在迷宫中点亮所有的灯并回到起点？

输入格式:

输入第一行给出三个正整数，分别表示地下迷宫的节点数NNN（11<N≤1000，表示通道所有交叉点和端点）、边数MMM（≤3000\le 3000≤3000，表示通道数）和探索起始节点编号SSS（节点从1到NNN编号）。随后的MMM行对应MMM条边（通道），每行给出一对正整数，分别是该条边直接连通的两个节点的编号。

输出格式:

若可以点亮所有节点的灯，则输出从SSS开始并以SSS结束的包含所有节点的序列，序列中相邻的节点一定有边（通道）；否则虽然不能点亮所有节点的灯，但还是输出点亮部分灯的节点序列，最后输出0，此时表示迷宫不是连通图。

由于深度优先遍历的节点序列是不唯一的，为了使得输出具有唯一的结果，我们约定以节点小编号优先的次序访问（点灯）。在点亮所有可以点亮的灯后，以原路返回的方式回到起点。

输入样例1:

6 8 1
1 2
2 3
3 4
4 5
5 6
6 4
3 6
1 5

输出样例1:

1 2 3 4 5 6 5 4 3 2 1

输入样例2:

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

输出样例2:

6 4 5 4 6 0

解题思路：

使用深度优先搜索，注意输出的格式。

提交代码：

编译器：g++

#include 
using namespace std;
const int MAXN = 1002;
bool Map[MAXN][MAXN];
bool vis[MAXN];
void DFS(int s, int n, bool isfirst);
int main()
{
    int n, m, s;
    int u, v;
    scanf("%d%d%d", &n, &m, &s);
    for(int i = 0; i < m; ++i)
    {
        scanf("%d%d", &u, &v);
        Map[u][v] = Map[v][u] = true;
    }
    vis[s] = true;
    DFS(s, n, true);
    for(int i = 1; i < n; ++i)
    {
        if(!vis[i])
        {
            printf(" 0");
            break;
        }
    }
    printf("\n");
    return 0;
}
void DFS(int s, int n, bool isfirtst)
{
    if(!isfirtst) printf(" ");
    else isfirtst = false;
    printf("%d", s);
    for(int i = 1; i <= n; ++i)
    {
        if(Map[s][i] && !vis[i])
        {
            vis[i] = true;
            Map[s][i] = Map[i][s] = false;
            DFS(i, n, isfirtst);
            printf(" %d", s); //表示返回又经过i点
        }
    }
}

Saving James Bond - Easy Version   (25分)

This time let us consider the situation in the movie "Live and Let Die" in which James Bond, the world's most famous spy, was captured by a group of drug dealers. He was sent to a small piece of land at the center of a lake filled with crocodiles. There he performed the most daring action to escape -- he jumped onto the head of the nearest crocodile! Before the animal realized what was happening, James jumped again onto the next big head... Finally he reached the bank before the last crocodile could bite him (actually the stunt man was caught by the big mouth and barely escaped with his extra thick boot).

Assume that the lake is a 100 by 100 square one. Assume that the center of the lake is at (0,0) and the northeast corner at (50,50). The central island is a disk centered at (0,0) with the diameter of 15. A number of crocodiles are in the lake at various positions. Given the coordinates of each crocodile and the distance that James could jump, you must tell him whether or not he can escape.

Input Specification:

Each input file contains one test case. Each case starts with a line containing two positive integersNNN (≤100\le 100≤100), the number of crocodiles, and DDD, the maximum distance that James could jump. Then NNN lines follow, each containing the (x,y)(x, y)(x,y) location of a crocodile. Note that no two crocodiles are staying at the same position.

Output Specification:

For each test case, print in a line "Yes" if James can escape, or "No" if not.

Sample Input 1:

14 20
25 -15
-25 28
8 49
29 15
-35 -2
5 28
27 -29
-8 -28
-20 -35
-25 -20
-13 29
-30 15
-35 40
12 12

Sample Output 1:

Yes

Sample Input 2:

4 13
-12 12
12 12
-12 -12
12 -12

Sample Output 2:

No

解题思路：

使用深度优先搜索，其联系是两点之间的距离。

如果两点的距离在跳跃范围之内，则表示两点联通

此外起点是在直径为15的圆周上，到达终点的判断也比较特殊。

提交代码：

编译器：g++

#include 
#include 
using namespace std;
const int MAXN = 102;
struct point{
    double x, y;
    double dis(const struct point px) {
        double xx = x - px.x;
        double yy = y - px.y;
        return sqrt(xx * xx + yy * yy);
    }
}p[MAXN];
bool vis[MAXN];
bool DFS(int s, int n, double d);
int main()
{
    int n, i;
    double d;
    scanf("%d%lf", &n, &d);
    p[0].x = p[0].y = 0;
    for(i =1; i <= n; ++i)
        scanf("%lf%lf", &p[i].x, &p[i].y);
    vis[0] = true;
    if(p[0].x + d + 7.5 >= 50 || -p[0].x + d + 7.5 >= 50)
        printf("Yes\n");
    else if(p[0].y + d + 7.5 >= 50 || -p[0].y + d +7.5 >= 50)
        printf("Yes\n");
    else //以上判断是否一下就能到岸，只要在跳跃范围内就算能到终点
    {
        for(i = 1; i <= n; ++i) //寻找一条通路
        {
            if(!vis[i] && p[0].dis(p[i]) <= d + 7.5) //是否在跳跃范围内
            {
                vis[i] = true;
                if(DFS(i, n, d))
                {
                    printf("Yes\n");
                    break;
                }
                else vis[i] = false;
            }
        }
        if(i > n) //如果所有情况都不能跳出
            printf("No\n");
    }
    return 0;
}
bool DFS(int s, int n, double d)
{
    double D = d;
    struct point tmp = p[s];
    if(tmp.x + D >= 50 || -tmp.x + D >= 50)
        return true;
    if(tmp.y + D >= 50 || -tmp.y + D >= 50)
        return true;
    for(int i = 1; i <= n; ++i)
    {
        if(!vis[i] && tmp.dis(p[i]) <= D) //是否在跳跃范围内
        {
            vis[i] = true;
            if(DFS(i, n, D)) return true;
            else vis[i] = false;
        }
    }
    return false;
}

列出连通集   (25分)

给定一个有NNN个顶点和EEE条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1N-1N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。

输入格式:

输入第1行给出2个整数NNN(00<N≤10)和EEE，分别是图的顶点数和边数。随后EEE行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。

输出格式:

按照"{ v1v_1v​1​​v2v_2v​2​​ ... vkv_kv​k​​ }"的格式，每行输出一个连通集。先输出DFS的结果，再输出BFS的结果。

输入样例:

8 6
0 7
0 1
2 0
4 1
2 4
3 5

输出样例:

{ 0 1 4 2 7 }
{ 3 5 }
{ 6 }
{ 0 1 2 7 4 }
{ 3 5 }
{ 6 }

解题思路：

根据题意直接使用两种搜索方式

提交代码：

编译器：g++

#include 
#include 
using namespace std;
const int MAXN = 12;
int Map[MAXN][MAXN];
void DoDFS(int n);
void DoBFS(int n);
void DFS(int n, int s, int *node);
void BFS(int n, int s, int *node);
int main()
{
    int n, m;
    int u, v;
    cin>>n>>m;
    for(int i = 0; i < m; ++i)
    {
        cin>>u>>v;
        Map[u][v] = Map[v][u]= true;
    }
    DoDFS(n);
    DoBFS(n);
    return 0;
}
void DoDFS(int n)
{
    int node[MAXN] = {false};
    for(int i = 0; i < n; ++i) //尝试每一个结点，并寻找出该点所在的连通集
    {
        if(!node[i]) //如果该点未遍历
        {
            node[i] = true;
            printf("{ %d", i);
            DFS(n, i, node);
            printf(" }\n");
        }
    }
}
void DFS(int n, int s, int *node)
{
    for(int i = 0; i < n; ++i)
    {
        if(!node[i] && Map[s][i])
        {
            node[i] = true;
            printf(" %d", i);
            DFS(n, i, node);
        }
    }
}
void DoBFS(int n)
{
    int node[MAXN] = {false};
    for(int i = 0; i < n; ++i) //同样尝试各个结点
    {
        if(!node[i])
        {
            printf("{");
            BFS(n, i, node);
            printf(" }\n");
        }
    }
}
void BFS(int n, int s, int *node)
{
    int q[MAXN] = {0}, f = 0, e = 0;
    node[s] = true;
    q[e++] = s;
    while(f < e)
    {
        int tmp = q[f++];
        printf(" %d", tmp);
        for(int i = 0; i < n; ++i)
        {
            if(!node[i] && Map[tmp][i])
            {
                node[i] = true;
                q[e++] = i;
            }
        }
    }
}

六度空间   (30分)

“六度空间”理论又称作“六度分隔（Six Degrees of Separation）”理论。这个理论可以通俗地阐述为：“你和任何一个陌生人之间所间隔的人不会超过六个，也就是说，最多通过五个人你就能够认识任何一个陌生人。”如图1所示。


图1 六度空间示意图

“六度空间”理论虽然得到广泛的认同，并且正在得到越来越多的应用。但是数十年来，试图验证这个理论始终是许多社会学家努力追求的目标。然而由于历史的原因，这样的研究具有太大的局限性和困难。随着当代人的联络主要依赖于电话、短信、微信以及因特网上即时通信等工具，能够体现社交网络关系的一手数据已经逐渐使得“六度空间”理论的验证成为可能。

假如给你一个社交网络图，请你对每个节点计算符合“六度空间”理论的结点占结点总数的百分比。

输入格式:

输入第1行给出两个正整数，分别表示社交网络图的结点数NNN（11<N≤10​4​​，表示人数）、边数MMM（≤33×N\le 33\times N≤33×N，表示社交关系数）。随后的MMM行对应MMM条边，每行给出一对正整数，分别是该条边直接连通的两个结点的编号（节点从1到NNN编号）。

输出格式:

对每个结点输出与该结点距离不超过6的结点数占结点总数的百分比，精确到小数点后2位。每个结节点输出一行，格式为“结点编号:（空格）百分比%”。

输入样例:

10 9
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10

输出样例:

1: 70.00%
2: 80.00%
3: 90.00%
4: 100.00%
5: 100.00%
6: 100.00%
7: 100.00%
8: 90.00%
9: 80.00%
10: 70.00%

解题思路：

使用广度优先搜索，只搜索距离在题设所给的范围内即可（注意边界）。

搜索过程中同时计数。

提交代码：

编译器：g++

#include 
#include 
using namespace std;
const int MAXN = 10002;
bool Map[MAXN][MAXN] = {false};
int BFS(int s, int n);
int main()
{
	int n, m;
	int u, v;
	scanf("%d%d", &n, &m);
	for(int i = 0; i < m; ++i)
	{
		scanf("%d%d",&u,&v);
		Map[u][v] = Map[v][u] = true;
	}
	for(int i = 1; i <= n; ++i)
	{
		int node = BFS(i, n);
		printf("%d: %.2lf%%\n", i, 100.0 * node / n);
	}
	return 0;
}
int BFS(int s, int n)
{
	int q[MAXN] = {0}, len[MAXN] = {0};
	int f = 0, e = 0, tmp;
	bool vis[MAXN] = {false};
	q[e++] = s;
	vis[s] = true;
	while(f < e)
	{
		tmp = q[f++];
		if(len[e - 1] > 6) break; //是否在题设范围内
		for(int i = 0; i <= n; ++i)
		{
			if(!vis[i] && Map[tmp][i])
				len[e] = len[f - 1] + 1, q[e++] = i, vis[i] = true; 
		}
	}
	for(tmp = 0; tmp < e && len[tmp] < 7; ++tmp);
	return tmp;
}

社交网络图中结点的“重要性”计算   (30分)

在社交网络中，个人或单位（结点）之间通过某些关系（边）联系起来。他们受到这些关系的影响，这种影响可以理解为网络中相互连接的结点之间蔓延的一种相互作用，可以增强也可以减弱。而结点根据其所处的位置不同，其在网络中体现的重要性也不尽相同。

“紧密度中心性”是用来衡量一个结点到达其它结点的“快慢”的指标，即一个有较高中心性的结点比有较低中心性的结点能够更快地（平均意义下）到达网络中的其它结点，因而在该网络的传播过程中有更重要的价值。在有NNN个结点的网络中，结点viv_iv​i​​的“紧密度中心性”Cc(vi)Cc(v_i)Cc(v​i​​)数学上定义为viv_iv​i​​到其余所有结点vjv_jv​j​​ (j≠ij\ne ij≠i) 的最短距离d(vi,vj)d(v_i, v_j)d(v​i​​,v​j​​)的平均值的倒数：

对于非连通图，所有结点的紧密度中心性都是0。

给定一个无权的无向图以及其中的一组结点，计算这组结点中每个结点的紧密度中心性。

输入格式:

输入第一行给出两个正整数NNN和MMM，其中NNN（≤104\le 10^4≤10​4​​）是图中结点个数，顺便假设结点从1到NNN编号；MMM（≤105\le 10^5≤10​5​​）是边的条数。随后的MMM行中，每行给出一条边的信息，即该边连接的两个结点编号，中间用空格分隔。最后一行给出需要计算紧密度中心性的这组结点的个数KKK（≤100\le 100≤100）以及KKK个结点编号，用空格分隔。

输出格式:

按照Cc(i)=x.xx的格式输出KKK个给定结点的紧密度中心性，每个输出占一行，结果保留到小数点后2位。

输入样例:

9 14
1 2
1 3
1 4
2 3
3 4
4 5
4 6
5 6
5 7
5 8
6 7
6 8
7 8
7 9
3 3 4 9

输出样例:

Cc(3)=0.47
Cc(4)=0.62
Cc(9)=0.35

解题思路：

根据题意，此处采用迪杰斯特拉算法，求某一点到各点的距离。

并根据到各点距离判断是否连通

如果连通则根据题中所给的公式计算结果。

提交代码：

编译器：g++

#include 
#include 
#include 
using namespace std;
const int MAXN = 10002;
const int INF = (1<<30);
int Map[MAXN][MAXN];
int dis[MAXN];
void dijkstral(int s, int n); //迪杰斯特拉算法
int main()
{
	int n, m, k;
	int u, v;
	bool islink = true;
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= n; ++j)
			Map[i][j] = INF;
	for(int i = 0; i < m; ++i)
	{
		scanf("%d%d", &u, &v);
		Map[u][v] = Map[v][u] = true;
	}
	scanf("%d", &k);
	for(int i = 0; i < k; ++i)
	{
		scanf("%d", &u);
		dijkstral(u, n); //求各个点到点u的距离
		int sum = 0;
		for(int i = 1; i <= n && islink; ++i)
		{
			if(dis[i] == INF) //如果与某个点不连通
			{
				sum = 0, islink = false;
				break;
			}
			sum += dis[i];
		}
		if(islink) //判断是否连通
			printf("Cc(%d)=%.2lf\n", u, 1.0 * (n - 1) / sum);
		else
			printf("Cc(%d)=0.00\n", u);
	}
	return 0;
}
void dijkstral(int s, int n)
{
	bool vis[n];
	for(int i = 1; i <= n; ++i)
		vis[i] = false,	dis[i] = Map[s][i];
	vis[s] = true;
	dis[s] = 0;
	for(int i = 1; i < n; ++i)
	{
		int Min = INF, index = s;
		for(int j = 1; j <= n; ++j)
			if(!vis[j] && Min > dis[j])
				Min = dis[j], index = j;
		vis[index] = true;
		for(int j = 1; j <= n; ++j)
			if(!vis[j] && dis[j] > dis[index] + Map[index][j])
				dis[j] = dis[index] + Map[index][j];
	}
}


公路村村通   (30分)

现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。

输入格式:

输入数据包括城镇数目正整数NNN（≤1000\le 1000≤1000）和候选道路数目MMM（≤3N\le 3N≤3N）；随后的MMM行对应MMM条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到NNN编号。

输出格式:

输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出−1-1−1，表示需要建设更多公路。

输入样例:

6 15
1 2 5
1 3 3
1 4 7
1 5 4
1 6 2
2 3 4
2 4 6
2 5 2
2 6 6
3 4 6
3 5 1
3 6 1
4 5 10
4 6 8
5 6 3

输出样例:

12

解题思路：

能否构成最小生成树

1）判断是否连通，此处采用并查集

2）如果连通，则输出结果

提交代码：

编译器：g++

#include 
#include 
#include 
using namespace std;
const int MAXN = 1002;
struct edge{
	int u, v;
	int cost;
	bool operator <(const struct edge E) const{
		return cost < E.cost;
	}
}e[MAXN * 3];
int root[MAXN];
int F(int x);
int main()
{
	int n, m;
	int cost = 0;
	scanf("%d%d", &n, &m);
	for(int i = 0; i <= n; ++i)
		root[i] = i;
	for(int i = 0; i < m; ++i)
		scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].cost);
	sort(e, e + m);//以下是Kruskal算法
	for(int i = 0; i < m; ++i)
	{
		int x = F(e[i].u);
		int y = F(e[i].v);
		if(x != y)
		{
			cost += e[i].cost;
			root[y] = x;
		}
	}//以下是判断是否连通
	for(int i = 1; i <= n; ++i)
		F(i);
	int tmp = root[1];
	for(int i = 2; i <= n; ++i)
		if(tmp != root[i]) tmp = -1;
	if(tmp > 0)
		printf("%d\n", cost);
	else
		printf("-1\n");
	return 0;
}
int F(int x)
{
	if(x != root[x])
		root[x] = F(root[x]);
	return root[x];
}


畅通工程之局部最小花费问题   (35分)

某地区经过对城镇交通状况的调查，得到现有城镇间快速道路的统计数据，并提出“畅通工程”的目标：使整个地区任何两个城镇间都可以实现快速交通（但不一定有直接的快速道路相连，只要互相间接通过快速路可达即可）。现得到城镇道路统计表，表中列出了任意两城镇间修建快速路的费用，以及该道路是否已经修通的状态。现请你编写程序，计算出全地区畅通需要的最低成本。

输入格式:

输入的第一行给出村庄数目NNN (1≤N≤1001\le N \le 1001≤N≤100)；随后的N(N−1)/2N(N-1)/2N(N−1)/2行对应村庄间道路的成本及修建状态：每行给出4个正整数，分别是两个村庄的编号（从1编号到NNN），此两村庄间道路的成本，以及修建状态 — 1表示已建，0表示未建。

输出格式:

输出全省畅通需要的最低成本。

输入样例:

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

输出样例:

3

解题思路：

对于题中所给的建立连接的点在生成最小生成树时不作考虑，

在未连接的点之间，建立最小生成树。

之后将总费用输出

提交代码：

编译器：g++

#include 
#include 
#include 
using namespace std;
const int MAXN = 4990;
struct infi{
	int u, v;
	int cost;
	bool operator <(const struct infi l) const{
		return cost < l.cost;
	}
}line[MAXN];
int root[MAXN];
int Find(int x);
int main()
{
	int n, tmpn, e;
	int u, v, cost, index = 0, totCost = 0, isbuild;
	scanf("%d", &n);
	tmpn = n, e = n * (n - 1) / 2;
	for(int i = 0; i <= n; ++i)
		root[i] = i;
	for(int i = 0; i < e; ++i)
	{
		scanf("%d %d %d %d", &u, &v, &cost, &isbuild);
		if(isbuild)
		{
			int x = Find(u);
			int y = Find(v);
			if(x != y)
				tmpn--, root[y] = x;
		}
		else
		{
			line[index].u = u, line[index].v = v;
			line[index].cost = cost, index++;
		}
	}
	sort(line, line + index);
	for(int i = 0; i < index && tmpn > 1; ++i)
	{
		int x = Find(line[i].u);
		int y = Find(line[i].v);
		if(x != y)
		{
			totCost += line[i].cost;
			root[y] = x;
			tmpn--;
		}
	}
	printf("%d\n", totCost);
	return 0;
}
int Find(int x)
{
	if(x != root[x])
		root[x] = Find(root[x]);
	return root[x];
}

旅游规划   (25分)

有了一张自驾旅游路线图，你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序，帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的，那么需要输出最便宜的一条路径。

输入格式:

输入说明：输入数据的第1行给出4个正整数NNN、MMM、SSS、DDD，其中NNN（2≤N≤5002\le N\le 5002≤N≤500）是城市的个数，顺便假设城市的编号为0~(N−1N-1N−1)；MMM是高速公路的条数；SSS是出发地的城市编号；DDD是目的地的城市编号。随后的MMM行中，每行给出一条高速公路的信息，分别是：城市1、城市2、高速公路长度、收费额，中间用空格分开，数字均为整数且不超过500。输入保证解的存在。

输出格式:

在一行里输出路径的长度和收费总额，数字间以空格分隔，输出结尾不能有多余空格。

输入样例:

4 5 0 3
0 1 1 20
1 3 2 30
0 3 4 10
0 2 2 20
2 3 1 20

输出样例:

3 40

解题思路：

求解最短路径，这道题省赛的时候也有同样的类型题。

此处使用迪杰斯特拉算法

由于有两个权值，者应确定两者的优先性（题中已给出）

下面直接上代码和注释啦

提交代码：

编译器：g++

#include 
#include 
using namespace std;
const int MAXN = 504;
const int INF = (1<<30);
struct infi{
	int len, cost;
}city[MAXN][MAXN], ans;
void shortpath(int n, int s, int d);
int main()
{
	int n, m, s, d;
	int u, v, l, c;
	scanf("%d%d%d%d", &n, &m, &s, &d);
	for(int i = 0; i < n; ++i)
		for(int j = 0; j < n; ++j)
			city[i][j].len = city[i][j].cost = INF; //初始化
	for(int i = 0; i < m; ++i) //读入信息
	{
		scanf("%d%d%d%d", &u, &v, &l ,&c);
		city[u][v].len = city[v][u].len = l;
		city[u][v].cost = city[v][u].cost = c;
	}
	shortpath(n, s, d);
	printf("%d %d\n", ans.len, ans.cost);
	return 0;
}
void shortpath(int n, int s, int d)
{
	int dis[MAXN], cost[MAXN] = {0};
	bool vis[MAXN] = {false};
	for(int i = 0; i < n; ++i) //初始化待求权值
		dis[i] = city[s][i].len, cost[i] = city[s][i].cost;
	vis[s] = true, dis[s] = 0, cost[s] = 0;
	for(int i = 1; i < n; ++i)
	{
		int Mindis = INF, Mincost = INF, index = s;
		for(int j = 0; j < n; ++j)
		{
			if(Mindis > dis[j] && !vis[j])
			{
				Mindis = dis[j];
				Mincost = cost[j];
				index = j;
			}
		}
		for(int j = 0; j < n; ++j)
		{
			if(!vis[j] && Mindis == dis[j] && Mincost > cost[j])
				Mincost = cost[j], index = j;
		} //以上是求得最小的权值的结点，将其并入已访问的集合
		vis[index] = true;
		for(int j = 0; j < n; ++j)
		{
			if(!vis[j])
			{
				if(dis[index] + city[index][j].len < dis[j]) //动态更新权值
				{
					dis[j] = dis[index] + city[index][j].len;
					cost[j] = cost[index] + city[index][j].cost; 
				}
				else if(dis[index] + city[index][j].len == dis[j])
				{
					if(cost[index] + city[index][j].cost < cost[j])
					{
						cost[j] = cost[index] + city[index][j].cost;
					}
				}
			}
		}
	}
	ans.len = dis[d], ans.cost = cost[d];
}

哈利·波特的考试   (25分)

哈利·波特要考试了，他需要你的帮助。这门课学的是用魔咒将一种动物变成另一种动物的本事。例如将猫变成老鼠的魔咒是haha，将老鼠变成鱼的魔咒是hehe等等。反方向变化的魔咒就是简单地将原来的魔咒倒过来念，例如ahah可以将老鼠变成猫。另外，如果想把猫变成鱼，可以通过念一个直接魔咒lalala，也可以将猫变老鼠、老鼠变鱼的魔咒连起来念：hahahehe。

现在哈利·波特的手里有一本教材，里面列出了所有的变形魔咒和能变的动物。老师允许他自己带一只动物去考场，要考察他把这只动物变成任意一只指定动物的本事。于是他来问你：带什么动物去可以让最难变的那种动物（即该动物变为哈利·波特自己带去的动物所需要的魔咒最长）需要的魔咒最短？例如：如果只有猫、鼠、鱼，则显然哈利·波特应该带鼠去，因为鼠变成另外两种动物都只需要念4个字符；而如果带猫去，则至少需要念6个字符才能把猫变成鱼；同理，带鱼去也不是最好的选择。

输入格式:

输入说明：输入第1行给出两个正整数NNN (≤100\le 100≤100)和MMM，其中NNN是考试涉及的动物总数，MMM是用于直接变形的魔咒条数。为简单起见，我们将动物按1~NNN编号。随后MMM行，每行给出了3个正整数，分别是两种动物的编号、以及它们之间变形需要的魔咒的长度(≤100\le 100≤100)，数字之间用空格分隔。

输出格式:

输出哈利·波特应该带去考场的动物的编号、以及最长的变形魔咒的长度，中间以空格分隔。如果只带1只动物是不可能完成所有变形要求的，则输出0。如果有若干只动物都可以备选，则输出编号最小的那只。

输入样例:

6 11
3 4 70
1 2 1
5 4 50
2 6 50
5 6 60
1 3 70
4 6 60
3 6 80
5 1 100
2 4 60
5 2 80

输出样例:

4 70

解题思路：

题目需要得到最长的变形魔咒，实际上是在这些最长魔咒中在得出最小值。

某个动物对应一条最长魔咒才能完成考试，也就是在一群动物中选出一只动物，它对应的魔咒最短。

此处依旧使用迪杰斯特拉算法，求得到个动物的最短魔咒

之后选择该动物完成考试需要的最长魔咒

最后在所有的动物中再选择最短的那个动物

提交代码：

编译器：g++

#include 
#include 
const int MAXN = 102;
const int INF = (1<<30);
int Map[MAXN][MAXN];
int shortpath(int s, int n);
int main()
{
	int n, m;
	int u, v, dis;
	int Min = INF, index = 1;
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= n; ++j)
			Map[i][j] = Map[j][i] = INF;
	for(int i = 0; i < m; ++i)
	{
		scanf("%d%d%d", &u, &v, &dis);
		Map[u][v] = Map[v][u] = dis;
	}
	for(int i = 1; i <= n; ++i) //选择对应魔咒最短的动物
	{
		int tmp = shortpath(i, n);
		if(tmp < Min)
		{
			Min = tmp;
			index = i;
		}
	}
	if(Min != INF)
		printf("%d %d\n", index, Min);
	else
		printf("0\n");
	return 0;
}
int shortpath(int s, int n)
{
	int dis[MAXN], Max = 0;
	bool vis[MAXN] = {false};
	for(int i = 1;i <= n; ++i)
		dis[i] = Map[s][i];
	vis[s] = true, dis[s] = 0;
	for(int i  = 1; i < n; ++i)
	{
		int Min = INF, index = s;
		for(int j = 1; j <= n; ++j)
		{
			if(!vis[j] && dis[j] < Min)
			{
				Min = dis[j], index = j;
			}
		}
		vis[index] = true;
		for(int j = 1; j <= n; ++j)
		{
			if(!vis[j] && dis[j] > dis[index] + Map[index][j])
			{
				dis[j] = dis[index] + Map[index][j];
			}
		}
	}
	for(int i = 1; i <= n; ++i) //选择最长的魔咒
	{
		Max = Max > dis[i]? Max: dis[i];
	}
	return Max;
}

城市间紧急救援   (25分)

作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。

输入格式:

输入第一行给出4个正整数NNN、MMM、SSS、DDD，其中NNN（2≤N≤5002\le N\le 5002≤N≤500）是城市的个数，顺便假设城市的编号为0 ~ (N−1)(N-1)(N−1)；MMM是快速道路的条数；SSS是出发地的城市编号；DDD是目的地的城市编号。

第二行给出NNN个正整数，其中第iii个数是第iii个城市的救援队的数目，数字间以空格分隔。随后的MMM行中，每行给出一条快速道路的信息，分别是：城市1、城市2、快速道路的长度，中间用空格分开，数字均为整数且不超过500。输入保证救援可行且最优解唯一。

输出格式:

第一行输出最短路径的长度和和能够召集的最多的救援队数量。第二行输出从SSS到DDD的路径中经过的城市编号。数字间以空格分隔，输出结尾不能有多余空格。

输入样例:

4 5 0 3
20 30 40 10
0 1 1
1 3 2
0 3 3
0 2 2
2 3 2

输出样例:

2 60
0 1 3

解题思路：

思路和算法同上一题，此处需要多处理经过的城市编号以及记录最短路劲的条数。

用一个数组标记当前城市是从哪个城市来的，即下标表示当前城市，数组内存放哪个城市为前缀

同时需要记录最短路径的条数，采用动态规划的思想，进行求解。

提交代码：

编译器：g++

/*
STL:
http://blog.csdn.net/qq_26437925/article/category/5731279/2
*/
#include 
using namespace std;
const int MAXN = 504;
const int INF = (1<<30);
int Map[MAXN][MAXN];
int team[MAXN];
void dijkstral(int s, int d, int n);
int main()
{
	int n, m, s, d;
	int u, v, dis;
	scanf("%d%d%d%d", &n, &m, &s, &d);
	for(int i = 0; i < n; ++i)
		for(int j = 0; j < n; ++j)
			Map[i][j] = Map[j][i] = INF;
	for(int i = 0; i < n; ++i)
		scanf("%d", &team[i]);
	for(int i = 0; i < m; ++i)
	{
		scanf("%d%d%d", &u, &v, &dis);
		Map[u][v] = Map[v][u] = dis;
	}
	dijkstral(s, d, n);
	return 0;
}
void dijkstral(int s, int d, int n)
{
	int dis[MAXN], peo[MAXN], pre[MAXN], plen[MAXN];
	int road[MAXN], way[MAXN];
	bool vis[MAXN];
	for(int i = 0; i < n; ++i)
	{
		if(Map[s][i] != INF) way[i] = 1;
		else way[i] = 0;
		dis[i] = Map[s][i];
		vis[i] = false;
		peo[i] = team[i] + team[s], pre[i] = s, plen[i] = 1;
	}
	dis[s] = 0, vis[s] = true, way[s] = 0;
	peo[s] = team[s], pre[s] = -1, plen[s] = 0;
	for(int i = 1; i < n; ++i)
	{
		int Mindis = INF, Maxpeo = 0, index = s;
		for(int j = 0; j < n; ++j)
		{
			if(!vis[j] && Mindis > dis[j])
				Mindis = dis[j], index = j;
			else if(!vis[j] && Mindis == dis[j] && Maxpeo < peo[j])
				Maxpeo = peo[j], index = j;
		}
		vis[index] = true;
		for(int j = 0; j < n; ++j)
		{
			if(!vis[j] && dis[j] > dis[index] + Map[index][j])
			{
				way[j] = way[index]; //到达j点，最多有way[index]条最短路
				pre[j] = index, plen[j] = plen[index] + 1; 
				dis[j] = dis[index] + Map[index][j];
				peo[j] = peo[index] + team[j]; 
			}
			else if(!vis[j] && dis[j] == dis[index] + Map[index][j])
			{
				way[j] += way[index]; //如果相同，则加上way[index]条新的方式
				if(peo[j] < peo[index] + team[j])
				{
					pre[j] = index, plen[j] = plen[index] + 1;
					peo[j] = peo[index] + team[j];
				}
			}
		}
		s = index;
	}
	s = d;
	for(int i = 0; i < plen[d]; ++i) //得到城市编号
		road[i] = pre[s], s = pre[s];
	printf("%d %d\n", way[d], peo[d]);
	for(int i = plen[d] - 1; i >= 0; --i)
		printf("%d ", road[i]);
	printf("%d\n", d);
}

任务调度的合理性   (25分)

假定一个工程项目由一组子任务构成，子任务之间有的可以并行执行，有的必须在完成了其它一些子任务后才能执行。“任务调度”包括一组子任务、以及每个子任务可以执行所依赖的子任务集。

比如完成一个专业的所有课程学习和毕业设计可以看成一个本科生要完成的一项工程，各门课程可以看成是子任务。有些课程可以同时开设，比如英语和C程序设计，它们没有必须先修哪门的约束；有些课程则不可以同时开设，因为它们有先后的依赖关系，比如C程序设计和数据结构两门课，必须先学习前者。

但是需要注意的是，对一组子任务，并不是任意的任务调度都是一个可行的方案。比如方案中存在“子任务A依赖于子任务B，子任务B依赖于子任务C，子任务C又依赖于子任务A”，那么这三个任务哪个都不能先执行，这就是一个不可行的方案。你现在的工作是写程序判定任何一个给定的任务调度是否可行。

输入格式:

输入说明：输入第一行给出子任务数NNN（≤100\le 100≤100），子任务按1~NNN编号。随后NNN行，每行给出一个子任务的依赖集合：首先给出依赖集合中的子任务数KKK，随后给出KKK个子任务编号，整数之间都用空格分隔。

输出格式:

如果方案可行，则输出1，否则输出0。

输入样例1:

12
0
0
2 1 2
0
1 4
1 5
2 3 6
1 3
2 7 8
1 7
1 10
1 7

输出样例1:

1

输入样例2:

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

输出样例2:

0

解题思路：

此处是需要拓扑排序，

直接参考百科中的执行步骤

提交代码：

编译器：g++

#include 
#include 
using namespace std;
const int MAXN = 102;
struct infi{
	int v;
	struct infi *next;
}*node[MAXN]; //用邻接表表示图
int Indegree[MAXN];
int q[MAXN];
int main()
{
	int n, m;
	int f = 0, e = 0, cnt = 0;
	scanf("%d", &n);
	for(int i = 0; i <= n; ++i)
	{
		node[i] = new struct infi;
 		node[i]->next = NULL, node[i]->v = i;
 	}
	for(int i = 1; i <= n; ++i)
	{
		scanf("%d", &m);
 		struct infi* tail = node[i];
		for(int i = 0; i < m; ++i)
		{
			struct infi *tmp = new struct infi;
			tmp->next = NULL;
			scanf("%d", &tmp->v);
			tail->next = tmp;
			tail = tmp;
			Indegree[tmp->v]++; //记录入度
		}
	}
	for(int i = 1; i <= n; ++i) //拓扑排序
		if(Indegree[i] == 0)
			q[e++] = i;
	while(f < e)
	{
		int v = q[f++];
		struct infi *head = node[v]->next;
		cnt++;
		while(head)
		{
			Indegree[head->v]--;
			if(Indegree[head->v] == 0)
				q[e++] = head->v;
			struct infi *tmp = head;
			head = head->next;
			delete tmp;
		}
	}
	if(cnt < n) printf("0\n");
	else printf("1\n");
	return 0;
}

你可能感兴趣的:(数据结构)

  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • 4.C_数据结构_队列 荣世蓥 数据结构数据结构
    概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • 【树一线性代数】005入门 Owlet_woodBird 算法
    Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
  • python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
    在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
  • 【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构leetcode算法
    给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 【高阶数据结构】并查集 椿融雪 数据结构与算法数据结构并查集
    文章目录一、并查集原理二、并查集实现三、并查集应用一、并查集原理在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，
  • python中文版软件下载-Python中文版 编程大乐趣
    python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
  • 开发游戏的学习规划 杰克逊的日记 游戏学习
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
  • 六、全局锁和表锁：给表加个字段怎么有这么多阻碍 nieniemin
    数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构。根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类。6.1全局锁全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flushtableswithreadlock(FTWRL)。当你需要让整个库处于
  • Golang Channel PandaSkr golang
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
  • ⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表 英雄哪里出来 《LeetCode算法全集》算法数据结构链表c++归并排序
    饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述  将两个不降序链表合并为一个新的不降
  • 数据结构 1 五花肉村长 数据结构算法开发语言c语言visualstudio
    1.什么是数据结构数据结构（DataStructure）是计算机存储和组织数据的方式，是指相互之间存在的一种或多种特定关系的数据元的集合。2.什么是算法算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《
  • 【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】 NeVeRMoRE_2024 数据结构与算法实践数据结构算法leetcodeb树
    数据结构和算法实践-树-LeetCode113-路径总和Ⅱ题目MyThought代码示例JAVA-8题目给你二叉树的根节点root和一个整数目标和targetSum，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。叶子节点是指没有子节点的节点输入：root=[5,4,8,11,null,13,4,7,2,null,null,5,1],targetSum=22输出：[[5,4,11,2],[
  • 【Python】数据结构,链表,算法详解 AIAdvocate python数据结构链表排序算法广度优先深度优先
    今日内容大纲介绍自定义代码-模拟链表删除节点查找节点算法入门-排序类的冒泡排序选择排序插入排序快速排序算法入门-查找类的二分查找-递归版二分查找-非递归版分线性结构-树介绍基本概述特点和分类自定义代码-模拟二叉树1.自定义代码-模拟链表完整版"""案例:自定义代码,模拟链表.​背景: 顺序表在存储数据的时候,需要使用到连续的空间,如果空间不够,就会导致扩容失败,针对于这种情况,我们可以通过链表实现
  • AI教你学Python 第4天：函数和模块 凡人的AI工具箱 AI教你学Pythonpython开发语言人工智能AIGC
    第四天：数据结构一、什么是数据结构？数据结构是计算机科学中用于组织和存储数据的特定方式。良好的数据结构能够提高数据的访问效率、修改频率和管理能力。Python提供了多种内置数据结构，如列表、元组、字典和集合，便于开发者更有效地处理数据。二、Python中的基本数据结构1.列表（List）定义：列表是一个有序的可变集合，允许重复元素。使用方括号[]表示。#示例：定义一个列表fruits=['appl
  • 互联网 Java 工程师面试题（Java 面试题四） 苹果酱0567 面试题汇总与解析java中间件开发语言springboot后端
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
  • C# Tuple、ValueTuple 語衣 C#知识补充c#
    栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
  • Rust中的所有权和借用规则详解 代码云1 rust开发语言后端
    Rust是一种系统编程语言，其设计目标包括内存安全、并发安全以及性能。为了实现这些目标，Rust引入了一系列独特的编程概念，其中最为核心的就是所有权（Ownership）和借用（Borrowing）规则。本文将详细解释Rust中的所有权和借用规则，以及它们如何确保内存安全和并发安全。一、所有权规则在Rust中，每一个值都有一个与之关联的所有者。这个所有者可以是变量、数据结构或者是其他形式的存储。所
  • 二叉树--python 电子海鸥 Python数据结构与算法python开发语言数据结构
    二叉树一、概述1、介绍是一种非线性数据结构，将数据一分为二，代表根与叶的派生关系，和链表的结构类似，二叉树的基本单元是结点，每个节点包括值和左右子节点引用。每个节点都有两个引用（类似于双向链表），分别指向左子节点和右子节点，该节点被称为这两个子节点的父节点。当给定一个二叉树的结点时，我们将在该节点的左子节点以及其以下结点所形成的树称为左子树，同理，右子节点的部分被称为右子树。在二叉树中，除了叶节点
  • 使用WAF防御网络上的隐蔽威胁之反序列化攻击 baiolkdnhjaio 网络安全
    什么是反序列化反序列化是将数据结构或对象状态从某种格式转换回对象的过程。这种格式通常是二进制流或者字符串（如JSON、XML），它是对象序列化（即对象转换为可存储或可传输格式）的逆过程。反序列化的安全风险反序列化的安全风险主要来自于处理不受信任的数据源时的不当反序列化。如果应用程序反序列化了恶意构造的数据，攻击者可能能够执行代码、访问敏感数据、进行拒绝服务攻击等。这是因为反序列化过程中可能会自动触
  • java 线程池 队列封装_java线程池（线程池组---分离任务队列和线程池） 爱打怪的小魔女 java线程池队列封装
    线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/消费者”模型。生产消费外部线程(生产者)－－－>任务消费者和生产者共享一个数据结构(缓存任务)PriorityQueue；生产者将任务添加到队列中，消费者从队列中取出数据；队列和线程池(线程池内部维护一个线程数组)，完全耦合在一起，当任务特别多，队列就不断的膨胀，增多，拥堵；就向车子过洞子另外一头走不掉，我靠，长龙(世界最长堵车世界纪录在天朝2
  • Linux的Initrd机制 被触发 linux
    Linux 的 initrd 技术是一个非常普遍使用的机制，linux2.6 内核的 initrd 的文件格式由原来的文件系统镜像文件转变成了 cpio 格式，变化不仅反映在文件格式上， linux 内核对这两种格式的 initrd 的处理有着截然的不同。本文首先介绍了什么是 initrd 技术，然后分别介绍了 Linux2.4 内核和 2.6 内核的 initrd 的处理流程。最后通过对 Lin
  • maven本地仓库路径修改 bitcarter maven
    默认maven本地仓库路径：C:\Users\Administrator\.m2 修改maven本地仓库路径方法：     1.打开E:\maven\apache-maven-2.2.1\conf\settings.xml     2.找到        
  • XSD和XML中的命名空间 darrenzhu xmlxsdschemanamespace命名空间
    http://www.360doc.com/content/12/0418/10/9437165_204585479.shtml http://blog.csdn.net/wanghuan203/article/details/9203621 http://blog.csdn.net/wanghuan203/article/details/9204337 http://www.cn
  • Java 求素数运算 周凡杨 java算法素数
    网络上对求素数之解数不胜数，我在此总结归纳一下，同时对一些编码，加以改进，效率有成倍热提高。 第一种：   原理: 6N(+-)1法         任何一个自然数，总可以表示成为如下的形式之一： 6N，6N+1，6N+2，6N+3，6N+4，6N+5 (N=0，1，2，…)   
  • java 单例模式 g21121 java
    想必单例模式大家都不会陌生，有如下两种方式来实现单例模式：   class Singleton { private static Singleton instance=new Singleton(); private Singleton(){} static Singleton getInstance() { return instance; }
  • Linux下Mysql源码安装 510888780 mysql
    1.假设已经有mysql-5.6.23-linux-glibc2.5-x86_64.tar.gz (1)创建mysql的安装目录及数据库存放目录       解压缩下载的源码包，目录结构，特殊指定的目录除外：           
  • 32位和64位操作系统 墙头上一根草 32位和64位操作系统
    32位和64位操作系统是指：CPU一次处理数据的能力是32位还是64位。现在市场上的CPU一般都是64位的，但是这些CPU并不是真正意义上的64 位CPU，里面依然保留了大部分32位的技术，只是进行了部分64位的改进。32位和64位的区别还涉及了内存的寻址方面，32位系统的最大寻址空间是2 的32次方= 4294967296（bit）= 4（GB）左右，而64位系统的最大寻址空间的寻址空间则达到了
  • 我的spring学习笔记10-轻量级_Spring框架 aijuans Spring 3
    一、问题提问：     → 请简单介绍一下什么是轻量级？     轻量级（Leightweight）是相对于一些重量级的容器来说的，比如Spring的核心是一个轻量级的容器，Spring的核心包在文件容量上只有不到1M大小，使用Spring核心包所需要的资源也是很少的，您甚至可以在小型设备中使用Spring。  
  • mongodb 环境搭建及简单CURD antlove WebInstallcurdNoSQLmongo
    一 搭建mongodb环境 1. 在mongo官网下载mongodb 2. 在本地创建目录 "D:\Program Files\mongodb-win32-i386-2.6.4\data\db" 3. 运行mongodb服务 [mongod.exe --dbpath "D:\Program Files\mongodb-win32-i386-2.6.4\data\
  • 数据字典和动态视图 百合不是茶 oracle数据字典动态视图系统和对象权限
    数据字典（data dictionary）是 Oracle 数据库的一个重要组成部分，这是一组用于记录数据库信息的只读（read-only）表。随着数据库的启动而启动,数据库关闭时数据字典也关闭   数据字典中包含   数据库中所有方案对象（schema object）的定义(包括表，视图，索引，簇，同义词，序列，过程，函数，包，触发器等等) 数据库为一
  • 多线程编程一般规则 bijian1013 javathread多线程java多线程
           如果两个工两个以上的线程都修改一个对象，那么把执行修改的方法定义为被同步的，如果对象更新影响到只读方法，那么只读方法也要定义成同步的。        不要滥用同步。如果在一个对象内的不同的方法访问的不是同一个数据，就不要将方法设置为synchronized的。
  • 将文件或目录拷贝到另一个Linux系统的命令scp bijian1013 linuxunixscp
    一.功能说明        scp就是security copy，用于将文件或者目录从一个Linux系统拷贝到另一个Linux系统下。scp传输数据用的是SSH协议，保证了数据传输的安全，其格式如下：        scp 远程用户名@IP地址：文件的绝对路径
  • 【持久化框架MyBatis3五】MyBatis3一对多关联查询 bit1129 Mybatis3
    以教员和课程为例介绍一对多关联关系，在这里认为一个教员可以叫多门课程，而一门课程只有1个教员教，这种关系在实际中不太常见，通过教员和课程是多对多的关系。   示例数据：   地址表：   CREATE TABLE ADDRESSES ( ADDR_ID INT(11) NOT NULL AUTO_INCREMENT, STREET VAR
  • cookie状态判断引发的查找问题 bitcarter formcgi
    先说一下我们的业务背景： 1.前台将图片和文本通过form表单提交到后台，图片我们都做了base64的编码，并且前台图片进行了压缩 2.form中action是一个cgi服务 3.后台cgi服务同时供PC，H5，APP 4.后台cgi中调用公共的cookie状态判断方法（公共的，大家都用，几年了没有问题） 问题：（折腾两天。。。。） 1.PC端cgi服务正常调用，cookie判断没
  • 通过Nginx,Tomcat访问日志(access log)记录请求耗时 ronin47
    一、Nginx通过$upstream_response_time $request_time统计请求和后台服务响应时间 nginx.conf使用配置方式： log_format main '$remote_addr - $remote_user [$time_local] "$request" ''$status $body_bytes_sent "$http_r
  • java-67- n个骰子的点数。 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。 bylijinnan java
    public class ProbabilityOfDice { /** * Q67 n个骰子的点数 * 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。 * 在以下求解过程中，我们把骰子看作是有序的。 * 例如当n=2时，我们认为（1，2）和（2，1）是两种不同的情况 */ private stati
  • 看别人的博客，觉得心情很好 Cb123456 博客心情
       以为写博客，就是总结，就和日记一样吧，同时也在督促自己。今天看了好长时间博客:    职业规划:    http://www.iteye.com/blogs/subjects/zhiyeguihua      android学习:    1.http://byandby.i
  • [JWFD开源工作流]尝试用原生代码引擎实现循环反馈拓扑分析 comsci 工作流
        我们已经不满足于仅仅跳跃一次，通过对引擎的升级，今天我测试了一下循环反馈模式，大概跑了200圈，引擎报一个溢出错误      在一个流程图的结束节点中嵌入一段方程，每次引擎运行到这个节点的时候，通过实时编译器GM模块，计算这个方程，计算结果与预设值进行比较，符合条件则跳跃到开始节点，继续新一轮拓扑分析，直到遇到
  • JS常用的事件及方法 cwqcwqmax9 js
    事件 描述 onactivate 当对象设置为活动元素时触发。 onafterupdate 当成功更新数据源对象中的关联对象后在数据绑定对象上触发。 onbeforeactivate 对象要被设置为当前元素前立即触发。 onbeforecut 当选中区从文档中删除之前在源对象触发。 onbeforedeactivate 在 activeElement 从当前对象变为父文档其它对象之前立即
  • 正则表达式验证日期格式 dashuaifu 正则表达式IT其它java其它
    正则表达式验证日期格式 function isDate(d){ var v = d.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/i); if(!v) { this.focus(); return false; } } <input value="2000-8-8" onblu
  • Yii CModel.rules() 方法 、validate预定义完整列表、以及说说验证 dcj3sjt126com yii
    public array rules () {return} array 要调用 validate() 时应用的有效性规则。 返回属性的有效性规则。声明验证规则，应重写此方法。 每个规则是数组具有以下结构：array('attribute list', 'validator name', 'on'=>'scenario name', ...validation
  • UITextAttributeTextColor = deprecated in iOS 7.0 dcj3sjt126com ios
    In this lesson we used the key "UITextAttributeTextColor" to change the color of the UINavigationBar appearance to white. This prompts a warning "first deprecated in iOS 7.0." Ins
  • 判断一个数是质数的几种方法 EmmaZhao Mathpython
    质数也叫素数，是只能被1和它本身整除的正整数，最小的质数是2，目前发现的最大的质数是p=2^57885161-1【注1】。 判断一个数是质数的最简单的方法如下： def isPrime1(n): for i in range(2, n): if n % i == 0: return False return True 但是在上面的方法中有一些冗余的计算，所以
  • SpringSecurity工作原理小解读 坏我一锅粥 SpringSecurity
      SecurityContextPersistenceFilter   ConcurrentSessionFilter   WebAsyncManagerIntegrationFilter   HeaderWriterFilter   CsrfFilter   LogoutFilter   Use
  • JS实现自适应宽度的Tag切换 ini JavaScripthtmlWebcsshtml5
    效果体验：http://hovertree.com/texiao/js/3.htm   该效果使用纯JavaScript代码，实现TAB页切换效果，TAB标签根据内容自适应宽度，点击TAB标签切换内容页。 HTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"
  • Hbase Rest API : 数据查询 kane_xie RESThbase
    hbase（hadoop）是用java编写的，有些语言（例如python）能够对它提供良好的支持，但也有很多语言使用起来并不是那么方便，比如c#只能通过thrift访问。Rest就能很好的解决这个问题。Hbase的org.apache.hadoop.hbase.rest包提供了rest接口，它内嵌了jetty作为servlet容器。   启动命令：./bin/hbase rest s
  • JQuery实现鼠标拖动元素移动位置（源码+注释） 明子健 jqueryjs源码拖动鼠标
    欢迎讨论指正！   print.html代码： <!DOCTYPE html> <html> <head> <meta http-equiv=Content-Type content="text/html;charset=utf-8"> <title>发票打印</title> &l
  • Postgresql 连表更新字段语法 update qifeifei PostgreSQL
    下面这段sql本来目的是想更新条件下的数据，可是这段sql却更新了整个表的数据。sql如下： UPDATE tops_visa.visa_order SET op_audit_abort_pass_date = now() FROM tops_visa.visa_order as t1 INNER JOIN tops_visa.visa_visitor as t2 ON t1.
  • 将redis,memcache结合使用的方案? tcrct rediscache
    公司架构上使用了阿里云的服务，由于阿里的kvstore收费相当高，打算自建，自建后就需要自己维护，所以就有了一个想法，针对kvstore(redis)及ocs(memcache)的特点，想自己开发一个cache层，将需要用到list，set，map等redis方法的继续使用redis来完成，将整条记录放在memcache下，即findbyid，save等时就memcache，其它就对应使用redi
  • 开发中遇到的诡异的bug wudixiaotie bug
    今天我们服务器组遇到个问题： 我们的服务是从Kafka里面取出数据，然后把offset存储到ssdb中，每个topic和partition都对应ssdb中不同的key，服务启动之后，每次kafka数据更新我们这边收到消息，然后存储之后就发现ssdb的值偶尔是-2,这就奇怪了，最开始我们是在代码中打印存储的日志，发现没什么问题，后来去查看ssdb的日志，才发现里面每次set的时候都会对同一个key
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他