算法课复习 -- 图、拓扑序、SCC

最新推荐文章于 2024-10-14 11:02:10 发布
最新推荐文章于 2024-10-14 11:02:10 发布
阅读量475 收藏
点赞数 1
分类专栏： 算法课复习 文章标签： 图论 拓扑 SCC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40993793/article/details/86019653
版权

HDU #1232 : 畅通工程

传送门：http://acm.hdu.edu.cn/showproblem.php?pid=1232

题意：给出n个点m条边，问至少还需要添加多少条边才能使整个图连通。

思路：对没有访问过的点进行dfs，每次dfs中的一团为一个连通块，答案即为“连通块数量-1”。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 2e9 + 10;
const int N = 410;
const double _e = 10e-6;
const int maxn = 1e3 + 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y;

int n, m;
bool used[maxn][maxn], vis[maxn];
vector<int> G[maxn];

void dfs(int u)
{
	vis[u] = true;
	for (int i = 0; i < G[u].size(); i++) {
		int v = G[u][i];
		if (!vis[v])
			dfs(v);
	}
}

int main()
{
	while (~scanf("%d", &n)) {
		if (n == 0)break;
		cl0(used); cl0(vis);
		for (int i = 1; i <= 1000; i++)
			G[i].clear();
		scanf("%d", &m);
		while (m--) {
			scanf("%d%d", &x, &y);
			if (!used[x][y]) {
				G[x].push_back(y);
				G[y].push_back(x);
				used[x][y] = 1; used[y][x] = 1;
			}
		}
		int ans = 0;
		for (int i = 1; i <= n; i++) {
			if (!vis[i]) {
				dfs(i);
				ans++;
			}
		}
		printf("%d\n", ans - 1);
	}
	return 0;
}

 

hihoCoder #1174 : 拓扑排序·一

传送门：https://hihocoder.com/problemset/problem/1174

题意：有n节课m个关系，对于每个关系a b表示a是b的前置课程，问课程安排有没有问题，也就是有没有环。

思路：记录每个点的入度，入度为0的放入队列。每次从队列取出点时将该点所有后置课程的入度-1，若后置课程入度为0则放入队列。当队列为空时结束，判断这时是否还有点的入度>0，如果有则有问题。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 2e9 + 10;
const int N = 410;
const double _e = 10e-6;
const int maxn = 1e5 + 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y;

int n, m;
int in[maxn];
vector<int> G[maxn];

int main()
{
	int t;
	scanf("%d", &t);
	while (t--) {
		cl0(in);
		for (int i = 1; i <= 100000; i++)
			G[i].clear();
		scanf("%d%d", &n, &m);
		while (m--) {
			scanf("%d%d", &x, &y);
			G[x].push_back(y);
			in[y]++;
		}
		queue<int> que;
		while (!que.empty())que.pop();
		for (int i = 1; i <= n; i++)
			if (in[i] == 0)que.push(i);
		while (!que.empty()) {
			int u = que.front(); que.pop();
			for (int i = 0; i < G[u].size(); i++) {
				int v = G[u][i];
				in[v]--;
				if (in[v] == 0) 
					que.push(v);
			}
		}
		bool judge = true;
		for (int i = 1; i <= n; i++) {
			if (in[i] > 0) {
				judge = false;
				break;
			}
		}
		if (judge)
			puts("Correct");
		else
			puts("Wrong");
	}
	return 0;
}

 

POJ #3249 : Test for Job

传送门：http://poj.org/problem?id=3249

题意：有n个点m条边，每个点有一个权值，问从一个入度为0的点沿边走到出度为0的点，最大的权值和是多少。

思路：拓扑同前一道题。维护点的最大权值和，sum[v]=max(sum[v],sum[u]+c[v])。当点的出度为0时，ans=max(ans，sum[u])。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 2e9 + 10;
const int N = 410;
const double _e = 10e-6;
const int maxn = 1e5 + 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y;

int n, m;
vector<int> G[maxn];
int c[maxn];
ll ans[maxn];
int in[maxn];

int main()
{
	while (~scanf("%d%d", &n, &m)) {
		cl0(in); 
		for (int i = 1; i <= 100000; i++) {
			ans[i] = -INF;
			G[i].clear();
		}
		for (int i = 1; i <= n; i++)
			scanf("%d", &c[i]);
		while (m--) {
			scanf("%d%d", &x, &y);
			G[x].push_back(y);
			in[y]++;
		}
		queue<int> que;
		for (int i = 1; i <= n; i++) {
			if (in[i] == 0) {
				que.push(i);
				ans[i] = c[i];
			}
		}
		ll anss = -INF;
		while (!que.empty()) {
			int u = que.front(); que.pop();
			if (G[u].size() == 0)
				anss = max(anss, ans[u]);
			for (int i = 0; i < G[u].size(); i++) {
				int v = G[u][i];
				in[v]--;
				ans[v] = max(ans[v], ans[u] + c[v]);
				if (in[v] == 0)
					que.push(v);
			}
		}
		printf("%lld\n", anss);
	}
	return 0;
}

 

HDU #1269 : 迷宫城堡

传送门：http://acm.hdu.edu.cn/showproblem.php?pid=1269

题意：求SCC（强连通分量）的个数是否为1。

思路：两种方法

第一种：直接tarjan求强连通分量。tarjan算法可以参考这篇：https://blog.csdn.net/qq_34374664/article/details/77488976

第二种：一共进行2次dfs。①在逆图上求拓扑序记录到栈（dfs，在点退出时入栈）；②将点从栈按顺序取出，若没访问过则进行dfs并且这一团为一个强连通分量。

AC代码：

//第一种：tarjan
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9;
const int N = 410;
const double _e = 10e-6;
const int maxn = 1e4 + 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y;

int n, m;
vector<int> G[maxn];
int no_sc, tot; int dfn[maxn], low[maxn], scc[maxn];
stack <int> s;

void tarjan(int u)
{
	dfn[u] = low[u] = ++tot; 
	s.push(u);
	for (int i : G[u]) {
		if (dfn[i] == 0) {
			tarjan(i);
			low[u] = min(low[u], low[i]);
		}
		else if (scc[i] == 0)
			low[u] = min(low[u], dfn[i]);
	}
	if (dfn[u] == low[u]) {
		no_sc++;
		while (1) {
			int x = s.top(); s.pop();
			scc[x] = no_sc; 
			if (x == u) break;
		}
	}
}

int main()
{
	while (~scanf("%d%d", &n, &m)) {
		if (n == 0 && m == 0)break;
		no_sc = 0;
		cl0(dfn); cl0(low); cl0(scc);
		for (int i = 1; i <= 10000; i++)
			G[i].clear();
		while (m--) {
			scanf("%d%d", &x, &y);
			G[x].push_back(y);
		}
		for (int i = 1; i <= n; i++)
			if (dfn[i] == 0) 
				tarjan(i);
		if (no_sc == 1)
			puts("Yes");
		else
			puts("No");
	}
	return 0;
}
//第二种：2次dfs
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9;
const int N = 410;
const double _e = 10e-6;
const int maxn = 1e4 + 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y;

int n, m;
vector<int> G[maxn], H[maxn];
stack <int> s;
bool used[maxn];

void topsort(int u)
{
	used[u] = true;
	for (int i = 0; i < H[u].size(); i++) {
		int v = H[u][i];
		if(!used[v])
			topsort(v);
	}
        s.push(u); 
}

void dfs(int u)
{
	used[u] = true;
	for (int i = 0; i < G[u].size(); i++) {
		int v = G[u][i];
		if (!used[v])
			dfs(v);
	}
}

int main()
{
	while (~scanf("%d%d", &n, &m)) {
		if (n == 0 && m == 0)break;		
		for (int i = 1; i <= 10000; i++) {
			G[i].clear();
			H[i].clear();
		}
		while (!s.empty())s.pop();
		while (m--) {
			scanf("%d%d", &x, &y);
			G[x].push_back(y);
			H[y].push_back(x);
		}
		cl0(used);
		for (int i = 1; i <= n; i++) {
			if (!used[i])topsort(i);
		}
		cl0(used);
		int cnt = 0;
		while (!s.empty()) {
			int u = s.top(); s.pop();
			if (!used[u]) {
				dfs(u);
				cnt++;
			}
		}
		if (cnt == 1)
			puts("Yes");
		else
			puts("No");
	}
	return 0;
}

 

POJ #2762 : Going from u to v or from v to u?

传送门：http://poj.org/problem?id=2762

题意：给一个n个点m条边的有向图。问是否能满足对于任意两点u v，使得从u能到v或从v能到u。

思路：先求强连通分量，以强连通分量为点建新图，新图是个DAG（有向无环图）。

由于每一块强连通分量内部是可以两两到达的，因此只要考虑新图上的点是否能从u到v或从v到u。

若要满足条件，新图必须为一条链。这里是利用拓扑来求的，当队列里同时出现>1个点时就为“No”。最后拓扑完后判断是否每个点都用过了，如果有点没用过的话也为“No”。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 2e9 + 10;
const int N = 410;
const double _e = 10e-6;
const int maxn = 1e3 + 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y;

int n, m;
vector<int> G[maxn], H[maxn];
int in[maxn];
bool used[maxn][maxn], vis[maxn];
int no_sc, tot; int dfn[maxn], low[maxn], scc[maxn];
stack <int> s;

void tarjan(int u)
{
	dfn[u] = low[u] = ++tot;
	s.push(u);
	for (int i = 0; i < G[u].size(); i++) {
		int v = G[u][i];
		if (dfn[v] == 0) {
			tarjan(v);
			low[u] = min(low[u], low[v]);
		}
		else if (scc[v] == 0)
			low[u] = min(low[u], dfn[v]);
	}
	if (dfn[u] == low[u]) {
		no_sc++;
		while (1) {
			int x = s.top(); s.pop();
			scc[x] = no_sc;
			if (x == u) break;
		}
	}
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--) {
		scanf("%d%d", &n, &m);
		no_sc = 0;
		cl0(dfn); cl0(low); cl0(scc); 
		cl0(used); cl0(vis); cl0(in);
		for (int i = 1; i <= 1000; i++) {
			G[i].clear();
			H[i].clear();
		}
		while (m--) {
			scanf("%d%d", &x, &y);
			G[x].push_back(y);
		}
		for (int i = 1; i <= n; i++)
			if (dfn[i] == 0)
				tarjan(i);
		
		for (int i = 1; i <= n; i++) {
			for (int j = 0; j < G[i].size(); j++) {
				int v = G[i][j];
				if (scc[i] != scc[v]&&!used[scc[i]][scc[v]]) {
					used[scc[i]][scc[v]] = true;
					H[scc[i]].push_back(scc[v]);
					in[scc[v]]++;
				}
			}
		}
		
		if (no_sc == 1) {
			puts("Yes");
			continue;
		}

		queue<int> que;
		while (!que.empty())
			que.pop();
		for (int i = 1; i <= no_sc; i++) {
			if (in[i] == 0) {
				que.push(i);
				vis[i] = true;
			}
		}
		if (que.size() > 1) {
			puts("No");
			continue;
		}
		bool judge = true;
		while (!que.empty()) {
			int u = que.front(); que.pop();
			for (int i = 0; i < H[u].size(); i++) {
				int v = H[u][i];
				in[v]--;
				if (in[v] == 0) {
					que.push(v);
					vis[v] = true;
				}
			}
			if (que.size() > 1) {
				puts("No");
				judge = false;
				break;
			}
		}
		if (judge) {
			for (int i = 1; i <= no_sc; i++) {
				if (!vis[i]) {
					judge = false;
					break;
				}
			}
			if (judge)
				puts("Yes");
			else
				puts("No");
		}
	}
	return 0;
}

 

__喵喵喵
关注
专栏目录
HEVC-SCC自适应调色板模式快速决策算法
01-27
该算法将图像亮度分量分块，并用离散余弦变换(DCT)来衡量每个块的复杂度，然后根据复杂度值形成判别矩阵，最后根据判别矩阵结合编码单元的信息来自适应地关闭或启用调色板模式，以减少计算量和编码时间。根据实验...
html-sass-scc-molengeek-siteweb
02-16
然而，如果SCC代表的是Site Context Clarity，那么它可能是一个专注于提升网站用户体验或数据分析的工具，帮助开发者更好地理解用户的行为和需求。 在“html-sass-scc-molengeek-siteweb-main”这个文件中，我们...
有向图强连通分量SCC（全网最好理解）
日拱一卒,功不唐捐
10-19 3338
定义： 在有向图中，如果一些顶点中任意两个顶点都能互相到达（间接或直接）,那么这些顶点就构成了一个强连通分量，如果一个顶点没有出度，即它不能到达其他任何顶点，那么该顶点自己就是一个强连通分量。 做题的总结吧算是： 1.给定一个有向图，求有多少个顶点是由任何顶点出发都可达的： 图中只有一个出度为0的点，那么它一定可以由任意点出发可达。SCC缩点后，DFS。 2.至少要选几个...
SCC重新建图
万箭穿心，习惯就好。
08-28 714
在通过求出
有向图的强连通分量（SCC）
weixin_42638946的博客
04-01 3973
有向图的强连通分量（SCC） 1. 有向图的强连通分量原理 原理 强连通分量是针对有向图来说的。如下的讲解默认都是针对有向图的。 连通分量：对于一个有向图中的一些点来说，如果任意两点都能相互到达，则称这些点以及对应的边构成连通分量。 强连通分量：指极大连通分量。即该联通分量中增加任何一个点都不能构成连通分量了。 那么强连通分量有什么作用呢？ 我们可以通过使用求解强联通分量的方式将一个有向图缩点成有向无环图（DAG），也称为拓扑图。缩点：指将强联通分量缩成一个点。 转化为拓扑图有什么好处
SGU 219 SCC + 拓扑序
neweryyy的博客
03-03 389
题意 传送门 SGU 219 Synchrograph 题解 将图分解强连通分量，考虑任一个 SCC。若图中存在边权为零的环，由于 SCC 中任意两点间存在回路，则可以构造出一个操作序列使边权集中在指向边权为零的环的边上，此时全部 SCC 中的点不满足 alive 的条件；若 SCC 中不存在零环，则对于一个环，无论如何操作，其边权总和不变，那么任意 SCC 中的点都满足条件。 将图中转移边权的操作看作流量，则 SCC 缩点得到的 DAG 中，入度为零的且不存在零环的 SCC 可以无限地向出边输出流量，不断
图的基本算法（DFS，BFS, topoSort，SCC）
北京的杨过
05-27 517
由于要面试的缘故，在看算法导论的图算法一节，决定把基本的算法都用java代码实现出来。 1. 图的表示，使用链接表的形式。 class TreeNode{ int nodeNum ; //节点编号 TreeNode parent = null; //遍历时的父节点 int dis = Integer.MAX_VALUE;// 距离源节点的路径 int discoverTi...
SCC.rar_SCC_matlabSCC算法_scc 分类_scc的工作原理_图像分类
09-19
SCC算法的核心思想是通过构建一个加权图，其中每个节点代表一个数据样本，边的权重表示样本之间的相似度。在初始阶段，每个样本被视为一个独立的类别。随后，算法进入迭代过程，不断调整类别边界，使得同类样本间的...
SCC-152M放电管SCC系列参数特性
07-29
SCC-152M放电管是硕凯 SOCAY 公司生产的玻璃气体放电管，主要用于设备的高压保护，特别是在通信系统、交通信号、计算机数据系统以及各种电子设备中，作为防雷和瞬时过压保护的重要元件。这款放电管的主要特点是其低...
Jadecy:Java库，用于计算（编码）deps，SCC和周期（Johnson算法）。-开源
04-25
它使用Tarjan算法进行SCC计算，并使用Johnson算法进行穷举循环计算，并使用连续而不是递归的方式进行处理，从而可以处理大图（<2 ^ 31个顶点）。 从1.1版开始，还可以计算出覆盖SCC所有边缘的最短周期。 也可以...
有向图的强连通分量（SCC）与无向图割点的一些细节，Tarjan
wanglianda2007的博客
02-06 175
一些细节
Tarjan算法求SCC（有向图强连通分量）
nyist_xiaod
08-06 3141
http://www.byvoid.com/blog/scc-tarjan/zh-hans/ http://blog.csdn.net/shiqi_614/article/details/7833628 dfn[u] 表示在 dfs 中 u 被访问的顺序标号。（时间戳 / time stamp） low[u] 表示 u 在栈中可以追溯到的的最远祖先的 dfn。 若 u 的子节点 v
算法之SCC
buzhidaolvtu的博客
01-25 2284
相关概念： 连通图 树 最小生成树 参考算法： https://www.geeksforgeeks.org/tarjan-algorithm-find-strongly-connected-components/ 应用： 在jacc编译器中使用SCC算法计算LALR的LookAhead符号，感觉比龙书中的算法更容易理解一些。 个人理解： 对算法
【判定弱连通】==【tarjan求scc + 缩点+拓扑】
lzs_lazy
05-27 678
给你一个N个点M条边的有向图，判断该图是否为弱连通。思路：首先tarjan求SCC + 缩点，建成新图后，可以证明的是，新图必定有入度为0的点。在保证每个点都有边相连的前提下，我们进行一次拓扑排序，在这个过程中若遇到不符合弱连通的条件即跳出。反之一直处理到队列为空，这时说明该图为弱连通图。遵循条件 一：新图不能有多于1个的入度为0的点，这是保证每个点都有边相连。 二：在拓扑排序遍历点u的过程中，
最大半连通子图——Tarjan求SCC，topsort求最长链，递推打表求方案数
qq_36314344的博客
07-17 102
题目：http://www.sqyoj.club/problem.php?id=1094 AC代码： #include<cstdio> #include<iostream> #include<cmath> #include<cstring> #include<algorithm> using namespace std; inl...
图算法之强连通分量（Strongly Connected Components, SCC）详细解读
最新发布
m0_61840987的博客
10-14 990
Kosaraju 算法：简单直观，通过两次深度优先搜索来找到强连通分量。 Tarjan 算法：一次深度优先搜索即可找到所有强连通分量，较为高效。 应用：强连通分量广泛应用于编译器优化、社交网络分析、数据库循环依赖检查等场景
[SCC]网络协议
romiqi
10-17 1053
描述 一些学校连接在一个计算机网络上。学校之间存在软件支援协议。每个学校都有它应支援的学校名单（学校 a 支援学校 b ，并不表示学校 b 一定支援学校 a ）。当某校获得一个新软件时，无论是直接得到还是网络得到，该校都应立即将这个软件通过网络传送给它应支援的学校。因此，一个新软件若想让所有连接在网络上的学校都能使用，只需将其提供给一些学校即可。 任务 请编一个程序，根据学校间支援协议（各个学校...
数据结构实验之查找七：线性之哈希表
Code_KK的博客
12-04 2360
数据结构实验之查找七：线性之哈希表 Time Limit: 1000MS Memory limit: 65536K 题目描述 根据给定的一系列整数关键字和素数p,用除留余数法定义hash函数H(Key)=Key%p,将关键字映射到长度为p的哈希表中，用线性探测法解决冲突。重复关键字放在hash表中的同一位置。 输入 连续输入多组数据，每
AcWing 368 差分约束系统 + Tarjan SCC + 拓扑序 DP
neweryyy的博客
03-19 119
题意 传送门 AcWing 368 题解 将各类关系转化为差分约束系统，求解各节点亮度的最小值，将其转化为求解最长路。 设 ddd 代表节点的亮度。T=1T=1T=1 时，d[A]−d[B]≥0,d[B]−d[A]≥0d[A]-d[B]\geq 0,d[B]-d[A]\geq 0d[A]−d[B]≥0,d[B]−d[A]≥0；T=2T=2T=2 时，d[B]−d[A]≥1d[B]-d[A]\geq 1d[B]−d[A]≥1；T=3T=3T=3 时，d[A]−d[B]≥0d[A]-d[B]\geq 0d[A
图像分类SCC算法的原理及应用分析
资源摘要信息:"SCC算法在图像处理中的应用" SCC算法，即稀疏编码分类器算法，是一种基于流行分类原理的图像处理技术。该算法的核心思想是通过稀疏表示的方式，将图像数据表示为少量的基向量的线性组合，从而实现对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值