关于图论的一些小结 （一）

最新推荐文章于 2021-03-05 23:01:04 发布
最新推荐文章于 2021-03-05 23:01:04 发布
阅读量435 收藏
点赞数
分类专栏： Data Structure
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cfzjxz/article/details/8093832
版权

图论的主要算法：

1.图的广度优先遍历：

–先遍历较近的点，一层层向外扩展
–常用队列存储当前正被展开的点
伪代码： 
	Q={s}; 标记s为己访问;
	while (Q非空) {
		取Q队首元素u;
		所有与u相邻且未被访问的点进入队列;
		标记u为已访问;
	}

 

一些应用：①无向图的连通分量                 

                  ②网络流计算

例题：UVA 439 骑士游历

#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <set>
#include <cctype>
#include <algorithm>
#include <cmath>
#include <deque>
#include <queue>
#include <map>
#include <stack>
#include <list>
#include <iomanip>
using namespace std;
///
///
#define INF 0xffffff7
#define maxn 5060
///
char startx, starty, endx, endy;
string pos1, pos2, tmp;
int main()
{
	///
	int i, j, k;
	queue<string> poss;
	while (cin >> pos1 >> pos2)
	{
		while (!poss.empty())
			poss.pop();
		starty = pos1[1];
		startx = pos1[0];
		endy = pos2[1];
		endx = pos2[0];
		
		int cnt = 0;
		int hp = 0, tp = 1, lc = 1; 
		poss.push(pos1);
		while (!poss.empty())
		{
			tmp = poss.front();
			poss.pop();
			hp++;
			if (tmp == pos2)
				break;
			char nexty, nextx;
			//方向1
			nexty = tmp[1] - 1;
			nextx = tmp[0] - 2;
			if (nexty <= '8' && nexty >= '1' && nextx <= 'h' && nextx >= 'a')
			{
				string tempStr = "";
				tempStr += nextx;
				tempStr += nexty;
				poss.push(tempStr);
				tp++;
			}
			//方向2
			nexty = tmp[1] + 1;
			nextx = tmp[0] - 2;
			if (nexty <= '8' && nexty >= '1' && nextx <= 'h' && nextx >= 'a')
			{
				string tempStr = "";
				tempStr += nextx;
				tempStr += nexty;
				poss.push(tempStr);
				tp++;
			}
			//方向3
			nexty = tmp[1] - 1;
			nextx = tmp[0] + 2;
			if (nexty <= '8' && nexty >= '1' && nextx <= 'h' && nextx >= 'a')
			{
				string tempStr = "";
				tempStr += nextx;
				tempStr += nexty;
				poss.push(tempStr);
				tp++;
			}
			//方向4
			nexty = tmp[1] + 1;
			nextx = tmp[0] + 2;
			if (nexty <= '8' && nexty >= '1' && nextx <= 'h' && nextx >= 'a')
			{
				string tempStr = "";
				tempStr += nextx;
				tempStr += nexty;
				poss.push(tempStr);
				tp++;
			}
			//方向5
			nexty = tmp[1] - 2;
			nextx = tmp[0] - 1;
			if (nexty <= '8' && nexty >= '1' && nextx <= 'h' && nextx >= 'a')
			{
				string tempStr = "";
				tempStr += nextx;
				tempStr += nexty;
				poss.push(tempStr);
				tp++;
			}
			//方向6
			nexty = tmp[1] + 2;
			nextx = tmp[0] - 1;
			if (nexty <= '8' && nexty >= '1' && nextx <= 'h' && nextx >= 'a')
			{
				string tempStr = "";
				tempStr += nextx;
				tempStr += nexty;
				poss.push(tempStr);
				tp++;
			}
			//方向7
			nexty = tmp[1] - 2;
			nextx = tmp[0] + 1;
			if (nexty <= '8' && nexty >= '1' && nextx <= 'h' && nextx >= 'a')
			{
				string tempStr = "";
				tempStr += nextx;
				tempStr += nexty;
				poss.push(tempStr);
				tp++;
			}
			//方向8
			nexty = tmp[1] + 2;
			nextx = tmp[0] + 1;
			if (nexty <= '8' && nexty >= '1' && nextx <= 'h' && nextx >= 'a')
			{
				string tempStr = "";
				tempStr += nextx;
				tempStr += nexty;
				poss.push(tempStr);
				tp++;
			}


			if (hp == lc)
			{
				cnt++;
				lc = tp;
			}
		}
		cout << "To get from " << pos1 << " to " << pos2 << " takes " << cnt <<  " knight moves." << endl;
	}
	
    ///
	///
    return 0;
}

TOJ 1056树的直径

两次BFS

#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <set>
#include <cctype>
#include <algorithm>
#include <cmath>
#include <deque>
#include <queue>
#include <map>
#include <stack>
#include <list>
#include <iomanip>
using namespace std;
///
///
#define INF 0xffffff7
#define maxn 1050
///
int C, R;
int nums = 0;
char maze[maxn][maxn];
bool vis[maxn][maxn];
int startx, starty;
struct pos{
	int y;
	int x;
};
int testcases;
pos pos2;
queue<pos> positons;
int maxnum;
void bfs(int starty, int startx)
{
	pos tmppos, tmp;
	int cnt = 0;
	int hp = 0, tp = 1, lc = 1;
	tmppos.y = starty;
	tmppos.x = startx;
	vis[starty][startx] = true;
	positons.push(tmppos);
	while (!positons.empty())
	{
		tmp = positons.front();
		positons.pop();
		hp++;
		int nexty, nextx;
		//方向1
		nexty = tmp.y;
		nextx = tmp.x - 1;
		if (nexty < R  && nexty >= 0 && nextx <= C && nextx >= 0 && vis[nexty][nextx] == false && maze[nexty][nextx] == '.')
		{
			pos pushpos;
			pushpos.y = nexty;
			pushpos.x = nextx;
			positons.push(pushpos);
			tp++;
			vis[nexty][nextx] = true;
		}
		//方向2
		nexty = tmp.y - 1;
		nextx = tmp.x;
		if (nexty < R  && nexty >= 0 && nextx <= C && nextx >= 0 && vis[nexty][nextx] == false && maze[nexty][nextx] == '.')
		{
			pos pushpos;
			pushpos.y = nexty;
			pushpos.x = nextx;
			positons.push(pushpos);
			tp++;
			vis[nexty][nextx] = true;
		}
		//方向3
		nexty = tmp.y;
		nextx = tmp.x + 1;
		if (nexty < R  && nexty >= 0 && nextx <= C && nextx >= 0 && vis[nexty][nextx] == false && maze[nexty][nextx] == '.')
		{
			pos pushpos;
			pushpos.y = nexty;
			pushpos.x = nextx;
			positons.push(pushpos);
			tp++;
			vis[nexty][nextx] = true;
		}
		//方向4
		nexty = tmp.y + 1;
		nextx = tmp.x;
		if (nexty < R  && nexty >= 0 && nextx <= C && nextx >= 0 && vis[nexty][nextx] == false && maze[nexty][nextx] == '.')
		{
			pos pushpos;
			pushpos.y = nexty;
			pushpos.x = nextx;
			positons.push(pushpos);
			tp++;
			vis[nexty][nextx] = true;
		}
		
		if (hp == lc)
		{
			cnt++;
			if (cnt > maxnum)
			{
				pos2 = tmp;
				maxnum = cnt;
			}
			lc = tp;
		}

	}

}
int main()
{
	///
	bool flag = true;
	int i, j, k;

	cin >> testcases;
	while (testcases--)
	{
		//清空队列，读入数据
		memset(vis, false, sizeof(vis));
		while (!positons.empty())
			positons.pop();
		cin >> C >> R;
		for (i = 0; i < R; i++)
			for (j = 0; j < C; j++)
			{
				cin >> maze[i][j];
				if (maze[i][j] == '.')
				{
					if (flag)
					{
						starty = i;
						startx = j;
						flag = false;
					}
				}
			}
		
		//开始计算
		maxnum = 0;
		bfs(starty, startx);

		memset(vis, false, sizeof(vis));
		while (!positons.empty())
			positons.pop();
		bfs(pos2.y, pos2.x);
		cout << "Maximum rope length is " << maxnum - 1 << "." << endl;
	}
	
    ///
	///
    return 0;
}


TOJ 2470 同一位置对应不同状态，vis[maxn][maxn][4]表示各个状态的BFS

对于不同的问题，应该明确到底具体每一步的状态究竟是什么

#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <set>
#include <cctype>
#include <algorithm>
#include <cmath>
#include <deque>
#include <queue>
#include <map>
#include <stack>
#include <list>
#include <iomanip>
using namespace std;
///
///
#define INF 0xffffff7
#define maxn 105
///
int M, N;
char maze[maxn][maxn];
int starty, startx, targety, targetx;
int cnt;
bool vis[maxn][maxn][4];
bool flag;

struct robotState{
	int posy;
	int posx;
	int dir;
	int steps;
};
robotState finalState;
queue<robotState> myWalking;
void bfs()
{
	int i, j;
	int hp = 0, tp = 1, lc = 1;
	robotState tmpState;
	tmpState.posy = starty;
	tmpState.posx = startx;
	tmpState.dir = 0;
	tmpState.steps = 0;
	vis[starty][startx][0] = true;
	myWalking.push(tmpState);
	while (!myWalking.empty())
	{
		robotState tmp;
		tmp = myWalking.front();
		myWalking.pop();
		hp++;
		if (tmp.posy == targety && tmp.posx == targetx)
		{
			flag = true;
			finalState = tmp;
			break;
		}

		robotState nextState;
		
		//向前一步
		if (tmp.dir == 0)
		{
			nextState.posy = tmp.posy - 1;
			nextState.posx = tmp.posx;
			nextState.dir = tmp.dir;
			nextState.steps = tmp.steps + 1;
		}
		else if (tmp.dir == 1)
		{
			nextState.posy = tmp.posy;
			nextState.posx = tmp.posx + 1;
			nextState.dir = tmp.dir;
			nextState.steps = tmp.steps + 1;
		}
		else if (tmp.dir == 2)
		{
			nextState.posy = tmp.posy + 1;
			nextState.posx = tmp.posx;
			nextState.dir = tmp.dir;
			nextState.steps = tmp.steps + 1;
		}
		else if (tmp.dir == 3)
		{
			nextState.posy = tmp.posy;
			nextState.posx = tmp.posx - 1;
			nextState.dir = tmp.dir;
			nextState.steps = tmp.steps + 1;
		}
		if (nextState.posy >= 0 && nextState.posy < M && nextState.posx >= 0 && nextState.posx < N && vis[nextState.posy][nextState.posx][nextState.dir] == false && maze[nextState.posy][nextState.posx] != '#')
		{
			myWalking.push(nextState);
			vis[nextState.posy][nextState.posx][nextState.dir] = true;
		}
		//右转
		nextState.posy = tmp.posy;
		nextState.posx = tmp.posx;
		nextState.dir = (tmp.dir + 1) % 4;
		nextState.steps = tmp.steps + 1;
		if (nextState.posy >= 0 && nextState.posy < M && nextState.posx >= 0 && nextState.posx < N && vis[nextState.posy][nextState.posx][nextState.dir] == false && maze[nextState.posy][nextState.posx] != '#')
		{
			myWalking.push(nextState);
			vis[nextState.posy][nextState.posx][nextState.dir] = true;
		}
		//左转
		nextState.posy = tmp.posy;
		nextState.posx = tmp.posx;
		nextState.dir = (tmp.dir - 1 + 4) % 4;
		nextState.steps = tmp.steps + 1;
		if (nextState.posy >= 0 && nextState.posy < M && nextState.posx >= 0 && nextState.posx < N && vis[nextState.posy][nextState.posx][nextState.dir] == false && maze[nextState.posy][nextState.posx] != '#')
		{
			myWalking.push(nextState);
			vis[nextState.posy][nextState.posx][nextState.dir] = true;
		}
		/*
		//方向1 向北
		nextState.posy = tmp.posy - 1;
		nextState.posx = tmp.posx;
		if (tmp.dir == 0)
		{
			nextState.steps = tmp.steps + 1;
		}
		else if (tmp.dir == 1 || tmp.steps == 3)
		{
			nextState.steps = tmp.steps + 2;
		}
		else if (tmp.dir == 2)
		{
			nextState.steps = tmp.steps + 3;
		}
		nextState.dir = 0;
		if (nextState.posy >= 0 && nextState.posy < M && nextState.posx >= 0 && nextState.posx < N && vis[tmp.posy][tmp.posx][0] == false && maze[nextState.posy][nextState.posx] != '#')
		{
			myWalking.push(nextState);
			vis[tmp.posy][tmp.posx][0] = true;
		}
		
		//方向2 向东
		nextState.posy = tmp.posy;
		nextState.posx = tmp.posx + 1;
		if (tmp.dir == 1)
		{
			nextState.steps = tmp.steps + 1;
		}
		else if (tmp.dir == 0 || tmp.dir == 2)
		{
			nextState.steps = tmp.steps + 2;
		}
		else if (tmp.dir == 3)
		{
			nextState.steps = tmp.steps + 3;
		}
		nextState.dir = 1;
		if (nextState.posy >= 0 && nextState.posy < M && nextState.posx >= 0 && nextState.posx < N && vis[tmp.posy][tmp.posx][1] == false && maze[nextState.posy][nextState.posx] != '#')
		{
			myWalking.push(nextState);
			vis[tmp.posy][tmp.posx][1] = true;
		}

		//方向3 向南
		nextState.posy = tmp.posy + 1;
		nextState.posx = tmp.posx;
		if (tmp.dir == 2)
		{
			nextState.steps = tmp.steps + 1;
		}
		else if (tmp.dir == 1 || tmp.dir == 3)
		{
			nextState.steps = tmp.steps + 2;
		}
		else if (tmp.dir == 0)
		{
			nextState.steps = tmp.steps + 3;
		}
		nextState.dir = 2;
		if (nextState.posy >= 0 && nextState.posy < M && nextState.posx >= 0 && nextState.posx < N && vis[tmp.posy][tmp.posx][2] == false && maze[nextState.posy][nextState.posx] != '#')
		{
			myWalking.push(nextState);
			vis[tmp.posy][tmp.posx][2] = true;
		}

		//方向4 向西
		nextState.posy = tmp.posy;
		nextState.posx = tmp.posx - 1;
		if (tmp.dir == 3)
		{
			nextState.steps = tmp.steps + 1;
		}
		else if (tmp.dir == 0 || tmp.dir == 2)
		{
			nextState.steps = tmp.steps + 2;
		}
		else if (tmp.dir == 1)
		{
			nextState.steps = tmp.steps + 3;
		}
		nextState.dir = 3;
		if (nextState.posy >= 0 && nextState.posy < M && nextState.posx >= 0 && nextState.posx < N && vis[tmp.posy][tmp.posx][3] == false && maze[nextState.posy][nextState.posx] != '#')
		{
			myWalking.push(nextState);
			vis[tmp.posy][tmp.posx][3] = true;
		}
		*/

	}
}
int main()
{
	///
	int i, j, k;
	int testcases;
	cin >> testcases;
	while (testcases--)
	{
		//初始化
		flag = false;
		cnt = 0;
		memset(vis, false, sizeof(vis));
		while (!myWalking.empty())
			myWalking.pop();
		//读入数据
		cin >> M >> N;
		for (i = 0; i < M; i++)
		{
			for (j = 0; j < N; j++)
			{
				cin >> maze[i][j];
				if (maze[i][j] == 'S')
				{
					starty = i;
					startx = j;
				}
				if (maze[i][j] == 'T')
				{
					targety = i;
					targetx = j;
				}
			}
		}
		
		bfs();
		if (flag)
			cout << finalState.steps << endl;
		else
			cout << -1 << endl;
	}

	
	///
    return 0;
}

深度优先搜索DFS的伪代码

dfs(int p) {
	timestamp = timestamp + 1;
	col[p] = GREY;
	d[p] = timestamp;
	for (每个与p相邻的点i)
		if (col[i] == WHITE) dfs(i);
	timestamp = timestamp + 1;
	f[p] = timestamp;
	col[p] = BLACK;
}

 

DFS遍历过程演示图
 

 

POJ 2817 TOJ 2281 Wordstack题目  比较经典的一道题目

既可以用暴力搜索进行解决（规模比较一般，但写起来比较麻烦）

也可以采用状态压缩的DP（方法相比于搜索复杂，但是代码很优美）

回顾集合运算：

                        判断j是否属于集合i：i&(1<<j)

                        在集合i中去除j：i-(1<<j)或者i&(!(1<<j))  i^(1<<j)

                        在集合i中加入点j：i|(1<<j);

先预处理出len[i][j]表示第i个字符串与第j个字符串组合能匹配的最大字符数，即如何摆放使得相邻的满足题意字符数目最多

好了，对于每一种字符选取状态，比如XXXXX5个字符串，对应2^5个选取状态，0表示没选中，1表示选中该字符串

dp[i][j]表示第i种状态下，以第j个字符串结尾所能达到的最大值

状态转移的公式为：

对于dp[i][j]而言，用标志k表示没选中的状态下标，然后尝试将第k个字符串加入到状态中，于是状态变为dp[i|(1<<k)][k]

dp[i|(1<<k)][k] = max(dp[i|(1<<k)][k],dp[i][j]+len[j][k]);

 

#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <set>
#include <cctype>
#include <algorithm>
#include <cmath>
#include <deque>
#include <queue>
#include <map>
#include <stack>
#include <list>
#include <iomanip>
using namespace std;
///
///
#define INF 0xffffff7
#define maxn 12
///
#define max(a,b)(a>b?a:b)
int dp[1026][11];
int len[11][11];
int n;
char str[11][11];

int main()
{
    ///
    int n, i, j, k, x, count;
    int len1, len2, max;
    while(scanf("%d",&n),n)
    {
        memset(len, 0, sizeof(len));
        for(i = 0; i < n; i++)
            scanf("%s", str[i]);
		//计算len[i][j]
        for(i = 0; i < n; i++)
		{
            for(j = 0; j < n; j++)
			{
                if(i != j)
                {
                    max = -1;//pay attention
                    len1 = strlen(str[i]);
                    len2 = strlen(str[j]);
                    for(k = 0; k < len1; k++)
                    {
                        count = 0;
                        for(x = 0; x<len2 && (x+k) < len1; x++)
                        {
                            if(str[i][x+k] == str[j][x]) 
								count++;
                        }
                        if(count > max) 
							max = count;
                    }
                    if(max > len[i][j])
                        len[i][j] = len[j][i] = max;
                }
            }
        }
		//自底向上计算
        memset(dp, 0, sizeof(dp));
		//对于i种状态而言
        for(i = 0; i < (1<<n); i++)
		{
			for (k = 0; k < n; k++)
			{
				//如果第k个字符没有在状态中
				if (!(i & 1 << k))
				{
					//遍历该状态中不同字符结尾情况，然后将其加入到状态尾部，更新状态
					for (j = 0; j < n; j++)
					{
						if (i & (1 << j))
							dp[i|(1<<k)][k] = max( dp[i|(1<<k)][k], dp[i][j] + len[j][k]);
					}
				}
			}
		//j放在外面的写法
		/*
        for(j = 0; j < n; j++)
        {
           if(i & (1 << j))//if j is in the set of i
           {
              for(k = 0; k < n; k++)
              {
                  if(!(i & (1<<k)))//if k is not int the set of i,then process dp
                     dp[i|(1<<k)][k] = max(dp[i|(1<<k)][k],dp[i][j] + len[j][k]);
              }
           }
        }
		*/
		}
        max = -1;
        for( i = 0; i < (1<<n); i++)
           for(j = 0; j < n; j++)
               if(dp[i][j] > max)
                  max = dp[i][j];
        printf("%d\n", max);
    }

	
	///
    return 0;
}

关于状态压缩DP的更多信息：http://blog.csdn.net/accry/article/details/6607703

cfzjxz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图论课程的教学感悟
06-03
本文主要针对华北科技学院开设的图论及其应用课程,研究在教学中避免图论理论的抽象难懂性的办法,阐明了在教学中案例教学的应用,简化这门课程理论难度。并指出图论在一些专业中的切实应用,注重和专业知识的衔接,结合教学经验,为提升学生学习兴趣,提升我校图论及其应用课程的教学质量提出解决方案。
图论部分简单总结
weixin_30563319的博客
03-27 156
总的感受: 这里大概囊括了一下图论的基础知识，图论是一个比较考验思维的部分。 尤其是后面有关二分图,网络流等的分支,对建模转化的要求还是很高的。 进入正题了： 一、最短路： 这一个部分不想多讲，虽然是很基础的一个部分，但是也很重要。 题目： 1、Telephone Lines。p.s:二分答案+最短路。 2、Roads and Planes。p.s:Topo序+dijkstra。 3、Cow Re...
图论感想
IWBE的专栏
10-23 2498
图论基础无非也就是图存储 遍历 有向图无向图的连通性 分为图联通和联通分量（有向图为强联通分量）  割点与割边   本人目前还没有看网络流内容，只是大致知道是什么。觉得也是图论一部分，个人认为学东西应该大体了解一下所学内容。每学一个必要好好思考，最好多点时候不看现成的算法，自己想好好思考一下如何解决此类问题。 我也是刚接触图论，觉得图论中dijstra和prim最小生成树 有很多相似之处。而ta
关于布局的一点心得
weixin_30566063的博客
07-12 83
1，要善于运用0dp结合layout_weight来填充剩余空间 2，对于高度，其实很多时候不需要高度必须为wrap_content;可以直接规定为具体数值 3，多使用这个属性： android:gravity="center_vertical"；这个结合上一条在很多时候很好用 4，在listview、gridview等控件中，记得加上这个属性： android:cacheColorH...
关于图论的一些小结 （二）
cfzjxz的专栏
10-23 425
连通分量求法： 强连通分量一定是图的深搜树的一个子树。 对于DAG，两次DFS，第一次DFS原图，第二次DFS反向图 求得各个强连通 DFS一种很文艺的写法 TOJ 2233题 /* 求强连通分量，做法:先对图进行DFS，记录每个节点的结束时间f[i] * 然后对反图按照f[i]从大到小的顺序对反图进行DFS，在中间过程中记录每个连通分量中最小的值，并将其赋值给其根节点 * 仍
35-图算法-小结1
08-03
在本课程"35-图算法-小结1"中，童咏昕教授从北京航空航天大学计算机学院为我们详细讲解了图算法的相关知识。这门课程是中国大学MOOC上的《算法设计与分析》系列课程的一部分，旨在帮助学生深入理解图算法的基础理论...
拓扑排序小结(知识讲解）.doc
07-09
拓扑排序是图论中的一个重要概念，主要用于解决有向无环图（DAG，Directed Acyclic Graph）中任务的顺序安排问题。它是一种特殊的排序，能够反映出图中顶点的相对前驱和后继关系。在拓扑排序中，一个顶点出现在另一...
算法导论课件 附原作者小结及答案
04-01
这门课程涵盖了算法的基础理论、重要算法及其在实际问题中的应用，同时附带了原作者的小结和答案，为学习者提供了宝贵的参考材料。 首先，我们来看看压缩包中包含的文件： 1. **算法导论 原作.pdf**：这是教材的...
Kruskal算法和prim算法求最小生成树学习小结（JAVA）
04-12
最小生成树是图论中的一个重要概念，用于寻找一个无向加权图的边集合，使得这些边连接所有顶点，并且这些边的总权重尽可能小。在这个问题上，Kruskal算法和Prim算法是非常经典的解决方案，它们都是在寻找图的最小...
基于分水岭变换和图论的图像分割方法
12-18
利用图像的局部灰度信息进行分水岭变换后, 将图像分割成多个小区域, 再结合各小区域的灰度和空间信息从全局角度用Norm a lized Cut方法在区域之间进行分割, 产生最终的分割结。实验结果表明, 该方法可以消除分水岭...
我的OI心得（二）之　图论（一）
何处 琼华
06-20 641
树与DFS树是一种特殊的图。一般的树有一个根节点，这个点是亘古以来就有的（盘古大神！！）。他会生出很多子节点，用一条（有向，无向，都可以，看需要）边相连。各子节点相互称“兄弟节点”，尊直接上司为“父节点”，父节点的父节点及以上称“祖宗节点”，唯一不好称呼的是。。。比如父节点的父节点的另一个子节点——叔伯节点？？显然除了根节点外每个节点都有且仅有一个父节点。除了叶子节点外，每个节点都有一或若干个子节点。树一般看需要有两种存法。一，父亲表示法。就是开个数组a，对于下标i表示节点编号，a[i]表示其父亲的编号。合
图论总结
二喵君的博客
11-22 249
来自大佬的分享，今晚和图论做个了结。【右击新标签页打开可以看的更清楚一些。】 恩，，文字总结发这里乱码了，只是学习资料，等真正的学完的总结吧。 https://download.csdn.net/my/uploads...
算法学习之路的心得五之图论基础
cascacasc的博客
03-05 227
GDUT 20 寒假集训专题5.图论基础 总结 题目题解 1.图的存储 目前我所知道的图的存储大致有三种， 第一种是用一个二维数组G[n] [m],对应的两个点如果有边就对应的赋值，但是要注意题目所给的是有向还是无向，有时候两个点之间有多重条边，这时候用二维数组来存的图就很高效的更新最短边(最长边)的值。 第二种是用stl里面的vector，设置一个v[n],来存图，用这个来存的优点是高效利用空间，还有后期搜索所有边也方便， 第三种是适合边中有多个条件，比如一条路里面有经过所需的时间，还有过路费，这时候
一次小总结：图论+数论+学长们
weixin_30765577的博客
07-14 230
　　用cnblogs就是好，用word编辑好了可以直接粘过去。 　　六 图论D1.串联位运算、bitset、搜索（迭代加深、估价）、树上数据结构、生成树、图的遍历（欧拉回路、拓扑排序、连通分量、2-SAT不懂不懂）+TEST 　　日 休息 　　一 图论D2.最短路、差分约束、网络流 　　二 图论D3.网络流加深+TEST 　　三 自习数学+数论讲解 　　四 数论讲解 　　五 即将进入...
一点心得
Time_Travel的博客
04-23 537
心得
图论专题总结
Bourbon
07-05 1213
ACM课程的最后一个专题，图论，其实这个专题还是比较有意思的，不过因为最后课时紧张，讲的也不是很详细。对于图也只是学个皮毛，因为快到期末考试了，题目做的也不是很多，其实还是学的东西不深，后面题目一难就不会做了。
数学建模图论算法学习总结
weixin_43791406的博客
04-15 3629
图论算法 ** 图论算法基础知识 ** B站视频链接： https://www.bilibili.com/video/av18374161/?p=35 https://www.bilibili.com/video/av37498689/?p=7 图论中的圈与块： https://wenku.baidu.com/view/44777a20a5e9856a5612604a.html ** 一、Dijk...
图论小结
yhcuac
09-07 252
一.图论的基本概念 有向图(有向边)，无向图(无向边)，顶点集合，边集合，顶点数(阶)，边数； 完全图，有向完全图，稀疏图，稠密图，平凡图(只有一个顶点)，零图(没有边)； 顶点的度数，奇点，偶点，最小度，最大度； 基本定理：度数之和等于边数的两倍； 度序列，可图(有限序列是度序列)； Havel-Hakimi定理：判断序列是否可图； 二部图(偶图)，完全二部图，二部图判定(无奇圈)； 同构；...
关于图论的一点心得
weixin_43941332的博客
01-17 3048
图的定义 ———关于大佬讲课及在oi wiki学习的一点体会 简单来说，图 就是一个结点的集合 和边的集合 ，其中任意一条边都可以表示为两个结点之间的关系。 有向边与无向边 如果边对结点的关系是双向的，那么这条边是无向边；如果是单向的，那么这条边是有向边。 图是怎么存的，get到以下几种做法。 1.临接矩阵 （二维的数组，s[i][j]表示i点与j点的距离。） 但显然需要占用很大多余的空间。对于一...
图论（C++）-最小生成树.pptx （无需积分，免费下载！！！！！）
最新发布
01-09
在本资源中，我们将深入探讨C++编程语言与图论的结合，特别是关于最小生成树的概念。图论是计算机科学中的一个重要分支，它研究的是由顶点和边组成的结构，广泛应用于网络设计、数据结构、算法分析等领域。C++作为一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值