PAT----图----连通图

无意识积累中

于 2022-03-04 19:22:52 发布

阅读量380

点赞数

分类专栏：得机试者得天下文章标签：深度优先算法数据结构

本文链接：https://blog.youkuaiyun.com/weiwei935707936/article/details/106561788

版权

得机试者得天下专栏收录该内容

15 篇文章

订阅专栏

_________________________________________________________

二.联通图

for大循环遍历所有N个节点:
- DFS
- cnt++
DFS:
- visit[index]=1
- for()if(!)DFS()

_________________________________________________________

连通图

1013

//1.有人说： 邻接矩阵遍历次数多， 会有超时问题， 用领接表会好一点
//2.领接表是取代不了邻接矩阵的， 因为有时候， 边上会带权重的（即无权重用表， 有权重， 用矩阵）
//3.真的是能用scanf和printf就用： 这次代码只是没用scanf就在最后一个样例超时， 改过之后通过
//4.PAT图的部分会在最后一个样例很大
//5.深刻理解用DFS判断连通图的原理




//1.核心: 联通分支的计算, visit[i]就相当于在之后的DFS或BFS将这个点隔离
//        (1)外层大循环, 遍历n, 调用DFS
//        (2)DFS: 走一遍所有自己能够走到的点
//                1)visit[index]
//                2)for()if(!visit)DFS()
//        (3)在DFS之前, 事先visit这个点就相当于断这个点
//        (4)想联通n个节点, 用n-1条边即可(把一个联通分支当成一个节点)
//2.这道题图的数据结构: 邻接矩阵--因为只有节点没有别的数据
//        (1)注意n和n+1
//        (2)如果是n+1: visit从1开始即可
//3.只有一个AC, 剩下都WA:  大概率逻辑写错了, 并且是每次都需要更新一遍的逻辑





//核心：  判断联通分支个数 + 去掉图中某点 

//1.判断联通分支个数： 
//      (1)for循环所有节点 
//      (2)!visit[i]则DFS,   cnt++ 
//      (3)DFS还是最基本的要素即可 

//2.去掉图中某点： 
//      (1)在DFS(或BFS)之前： visit[index]=1 


#include <iostream>
#include <vector>
#include <algorithm>


using namespace std;

int n, m, k, cnt;

vector<vector<int> >graph;
vector<int>visit;

void DFS(int index) {
	visit[index] = 1;

	for (int i = 0; i < graph[index].size(); i++) 
		if (!visit[graph[index][i]])DFS(graph[index][i]);
}

int main() {
	scanf("%d %d %d", &n, &m, &k);
	graph.resize(n + 1);
	visit.resize(n + 1);
	for (int i = 0; i < m; i++) {
		int a, b;
		scanf("%d %d", &a, &b);
		graph[a].push_back(b);
		graph[b].push_back(a);
	}

	for (int i = 0; i < k; i++) {
		int tmp;
		scanf("%d", &tmp);
		fill(visit.begin(), visit.end(), 0);
		visit[tmp] = 1;
		cnt = 0;

		for (int j = 1; j <= n; j++) 
			if (!visit[j]) { 
				DFS(j); 
				cnt++;
			}
		
		printf("%d\n", (cnt - 1));

	}


	return 0;
}

连通图，图的深度

1021

// 1.连通图的判断： 外面一个for， 里面一个if
// 2.树和图的deep: 递归带到参数里。 如果想要最深：全局变量判断






//核心：  记录层数+判断联通分支个数 

//1.记录层数：  
//      (1)DFS: 调用时level=0,  递归传参更新 
//      (2)BFS: while: level++ 

//2.联通分支个数： 
//      (1)for每个节点
//      (2)if(!visit[i])DFS；cnt++； 

//3.记录最大的思想， 只需要一个max=0记录即可。 

//4.组织代码经验： 
//      (1)这道题：  判断联通分支 + 每个节点判断是否最大，  任务比较多， 容易糊涂 
//      (2)这种时候， 不要怕代码重复： 每个任务分开解决 

#include <iostream>
#include <vector>
#include <algorithm>


using namespace std;

int n,cnt=0, maxLevel=0, MAX=0;

vector<vector<int> >graph;
vector<int>visit;
vector<int>levels, results;

void DFS(int index, int level) {
	visit[index] = 1;
	level++;
	if (level > maxLevel)maxLevel = level;

	for (int i = 0; i < graph[index].size(); i++) {
		if (!visit[graph[index][i]])DFS(graph[index][i], level);
	}

}

int main() {
	scanf("%d", &n);
	graph.resize(n + 1);
	visit.resize(n + 1);
	levels.resize(n + 1);
	for (int i = 1; i < n; i++) {
		int a, b;
		scanf("%d %d", &a, &b);
		graph[a].push_back(b);
		graph[b].push_back(a);
	}

	//获得联通分支个数
	fill(visit.begin(), visit.end(), 0);
	for (int i = 1; i <= n; i++) {
		if (!visit[i]) {
			DFS(i,0);
			cnt++;
		}
	}

	if (cnt != 1) {
		printf("Error: %d components\n", cnt);
		return 0;
	}

    //获得最大层的根
	for (int i = 1; i <= n; i++) {
		fill(visit.begin(), visit.end(), 0);
		maxLevel = 0;
		DFS(i, 0);
		levels[i] = maxLevel;
		if (MAX < maxLevel)MAX = maxLevel;
	}

	for (int i = 1; i < levels.size(); i++)
		if (levels[i] == MAX)results.push_back(i);

	sort(results.begin(), results.end());

	for (int i = 0; i < results.size(); i++)printf("%d\n", results[i]);

	return 0;
}

“有向”有环的连通图

1034

//1.图论如果没有给节点个数， 只给了边的个数何解？（触类旁通：记住没有给定需要数据的暴力思考方式）
//答：看清题目，特殊情况的量一般比较小， 用比较暴力的数据结构和算法是可以的
//    其实这种情况下是往往更简单的。
//2.如果不是数层数， 递归中遇到的变量最好是全局变量
//3.scanf不要忘了加：&
//4.如果输出的东西很奇怪要检查一下是否因为C语言的原因printf输出不了
//5.字符和int的互转大写：65， 小写：97
//6.有向图求和边有关系的量的时候， 注意DFS并不全对：边的遍历for中if之外
//7.传统的DFS对付不了有向有环图
//8.iterator使用不当的话， 容易出现段错误
//9.!!!血的教训：数组开小了会有Segmentation Fault！！！！！


//1.核心:  
//    (1)连通图:  大循环 + if(visit) + cnt++
//    (2)每个联通分支的 大小, 最大值, 总值:  DFS的时候处理
 
//2.数据结构:
//    (1)节点为字符串, 就用sToi, iTos两个数组配合
//    (2)有weight的明显用邻接表而非邻接矩阵
//    (3)最后有排序输出:明显用vector

//3.如果可以还是列一个大纲, debug的时候也不要干看, 动手啊
//  发现你所有被浪费的时间其实都是因为干看



//#include <bits/stdc++.h>
#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <set>
#include <algorithm>
using namespace std;

unordered_map<string, int>nodes;
vector<vector<int> >graph(2001, vector<int>(2001, 0));
vector<int>visit(2001, 0);
vector<int>weights(2001, 0);
vector<pair<int, int> >results;
vector<pair<string, int> >print;

int maxIndex, cntComp, sumComp, nodeNum = 0;



void DFS(int index) {
	visit[index] = 1;
	if (weights[index] > weights[maxIndex])maxIndex = index;
	cntComp++;
	//cout << "!!!index: " << index << endl;

	for (int i = 1; i <= nodeNum; i++) {
		sumComp += graph[index][i];
		if (graph[index][i] != 0 && (!visit[i])) {
            //sumComp += graph[index][i];
			//cout << "index"<<index << "i"<<i<<"sumComp"<<sumComp << endl;
			DFS(i);
		}
	}

}

bool cmp(pair<string, int> a, pair<string, int> b) {
	return a.first < b.first;
}


int main() {

	//输入
	int n, k;
	scanf("%d %d\n", &n, &k);

	//映射 字符串型节点 和 数字
	for (int i = 0; i < n; i++) {
		string a, b;
		int weight;
		cin >> a >> b >> weight;
		if (nodes.find(a) == nodes.end()) {
			nodeNum++;
			nodes[a] = nodeNum;
		}
		if (nodes.find(b) == nodes.end()) {
			nodeNum++;
			nodes[b] = nodeNum;
		}

		graph[nodes[a]][nodes[b]] += weight;
		graph[nodes[b]][nodes[a]] += weight;
	}

	检查输入
	//cout << "nodeNum" << nodeNum << endl;
	//unordered_map<string, int>::iterator iter;
	//for (iter = nodes.begin(); iter != nodes.end(); iter++)cout<<iter->first<<" " << iter->second << " ";
	//cout << endl;

	//for (int i = 1; i <= nodeNum;i++) {
	//	for (int j = 1; j <= nodeNum;j++) {
	//		cout << graph[i][j] << " ";
	//	}
	//	cout << endl;
	//}

	//计算每个节点的权重：权重没有明确定义， 这里暂时出度，入度都算，出错检查此处
	for (int i = 1; i <= nodeNum; i++) {
		int sum = 0;
		for (int j = 1; j <= nodeNum; j++) {
			if (j != i) sum += graph[i][j];
		}
		sum += graph[i][i];
		weights[i] = sum/2;
	}

	检查权重
	//for (int i = 1; i <= nodeNum; i++) {
	//	cout << "weight " << i << ": " <<weights[i]<< endl;
	//}


	//联通： 确定连通分量个数， 找出每个分量权重最大， 确定每个分量节点个数
	int componet = 0;  //联通分支
	for (int i = 1; i <= nodeNum; i++) {
		if (!visit[i] && (weights[i] != 0)) {
			maxIndex = 0, cntComp = 0, sumComp = 0;  //head, 分支节点数， 分支权重和
			DFS(i);
			componet++;
			//cout << "maxIndex:" << maxIndex << "cntComp:"<< cntComp <<"sumComp:"<< sumComp <<endl;
			if (cntComp > 2 && (sumComp/2 > k)) {
				pair<int, int>tmp(maxIndex, cntComp);
				results.push_back(tmp);
			}
		}
	}

    //因为节点由string转成int, 前面的算法得到的是int, 这里需要转一下, 其实也可以用两个map
	if (results.size() != 0) {
		vector<pair<int, int>>::iterator iter1;
		unordered_map<string, int>::iterator iter2;
		for (iter1 = results.begin(); iter1 != results.end(); iter1++) {
			for (iter2 = nodes.begin(); iter2 != nodes.end(); iter2++) {
				if (iter1->first == iter2->second) {
					pair<string, int>tmp;
					tmp.first = iter2->first;
					tmp.second = iter1->second;
					print.push_back(tmp);
				}
			}
		}
		sort(print.begin(), print.end(), cmp);
	}

	

	//输出
	if (componet == 0 || (print.size() == 0))printf("0\n");
	else {
		printf("%d\n", print.size());
		for (int i = 0; i < print.size(); i++) {
			cout << print[i].first << " " << print[i].second << endl;
		}
	}

	return 0;
}