网络流学习计划

最新推荐文章于 2022-09-15 09:21:10 发布
最新推荐文章于 2022-09-15 09:21:10 发布
阅读量167 收藏
点赞数 1
分类专栏： 网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mega_Aspirin/article/details/99608242
版权

EK就跳过了，计划noip前尽量做完网络流24题吧。

//上面这个flag已弃。。。现在主要任务是水dp题
//偶尔会肝一道防止忘记板子

【模板】网络最大流 dinic

Code:

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
#define MAXN 1000010
#define INF 999999999
using namespace std;

struct fls {
	int to, next, val;
}edge[MAXN << 1];

int head[MAXN << 1], level[MAXN], q[MAXN], n, m, S, T, cnt, t, w;

inline int read () {
	register int s = 0, w = 1;
	register char ch = getchar ();
	while (! isdigit (ch)) {if (ch == '-') w = -1; ch = getchar ();}
	while (isdigit (ch)) {s = (s << 3) + (s << 1) + (ch ^ 48); ch = getchar ();}
	return s * w;
}

inline void connect (int u, int v, int w) {
	edge[++cnt].to = v, edge[cnt].val = w, edge[cnt].next = head[u], head[u] = cnt;
}

inline bool BFS () {
	memset (level, -1, sizeof level);
	memset (q, 0, sizeof q);
	level[S] = 0, q[t = w = 1] = S;
	while (t <= w) {
		int now = q[t];
		for (register int i = head[now]; i != -1; i = edge[i].next) {
			int v = edge[i].to;
			if (edge[i].val != 0 && level[v] == -1) {
				level[v] = level[now] + 1;
				q[++w] = v;
			}
		}
		t++;
	}
	if (level[T] != -1) return 1;
	return 0;
}

int DFS (int now, int flow) {
	int ret = flow; if (now == T) return flow;
	for (register int i = head[now]; i != -1; i = edge[i].next) {
		int v = edge[i].to; if (ret <= 0) break;
		if (edge[i].val != 0 && level[now] + 1 == level[v]) {
			int o = DFS (v, min (edge[i].val, ret));
			ret -= o, edge[i].val -= o, edge[i ^ 1].val += o;
		}
	}
	return flow - ret;
}

void dinic () {
	int ans = 0;
	while (BFS () == 1) ans += DFS (S, INF);
	printf ("%d\n", ans);
}

int main () {
	memset (head, -1, sizeof head), cnt = 1;
	n = read (), m = read (), S = read (), T = read ();
	for (register int i = 1; i <= m; i++) {
		int u = read (), v = read (), w = read ();
		connect (u, v, w), connect (v, u, 0);
	}
	dinic (); return 0;
}

【模板】二分图匹配 dinic

二分图dinic O ( n 2 n ) O(n^2\sqrt n) O(n2n ​) 吊打暴力匈牙利 O ( n 3 ) O(n^3) O(n3)
思路：建立超级源点 S ( 0 ) S(0) S(0)，超级汇点 T ( n 1 + n 2 + 1 ) T(n1+n2+1) T(n1+n2+1)
S S S向二分图左部连边，二分图右部向 T T T连边，二分图内部按要求互相连边。
所有正向边边权为1，反向边边权为0，跑一边dinic即可。

Code:

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
#define MAXN 1000010
#define INF 999999999
using namespace std;

struct fls {
	int to, next, val;
}edge[MAXN << 1];

int head[MAXN << 1], level[MAXN], q[MAXN], n, m, S, T, n1, n2, t, w, cnt = 1;

inline int read () {
	register int s = 0, w = 1;
	register char ch = getchar ();
	while (! isdigit (ch)) {if (ch == '-') w = -1; ch = getchar ();}
	while (isdigit (ch)) {s = (s << 3) + (s << 1) + (ch ^ 48); ch = getchar ();}
	return s * w;
}

inline void connect (int u, int v, int w) {
	edge[++cnt].to = v, edge[cnt].val = w, edge[cnt].next = head[u], head[u] = cnt;
}

inline bool BFS () {
	memset (level, -1, sizeof level);
	memset (q, 0, sizeof q);
	level[S] = 0, q[t = w = 1] = S;
	while (t <= w) {
		int now = q[t];
		for (register int i = head[now]; i; i = edge[i].next) {
			int v = edge[i].to;
			if (edge[i].val != 0 && level[v] == -1) {
				level[v] = level[now] + 1;
				q[++w] = v;
			}
		}
		t++;
	}
	if (level[T] != -1) return 1;
	return 0;
}

int DFS (int now, int flow) {
	int ret = flow; if (now == T) return flow;
	for (register int i = head[now]; i; i = edge[i].next) {
		int v = edge[i].to; if (ret <= 0) break;
		if (edge[i].val != 0 && level[now] + 1 == level[v]) {
			int o = DFS (v, min (edge[i].val, ret));
			ret -= o, edge[i].val -= o, edge[i ^ 1].val += o;
		}
	}
	return flow - ret;
}

void dinic () {
	int ans = 0;
	while (BFS () == 1) ans += DFS (S, INF);
	printf ("%d\n", ans);
}

int main () {
	n1 = read (), n2 = read (), m = read (), S = 0, T = n1 + n2 + 1;
	for (register int i = 1; i <= n1; i++) connect (S, i, 1), connect (i, S, 0);
	for (register int i = n1 + 1; i <= n1 + n2; i++) connect (i, T, 1), connect (T, i, 0);
	for (register int i = 1; i <= m; i++) {
		int u = read (), v = read () + n1;
		if (u > n1 || v > n1 + n2) continue;
		connect (u, v, 1), connect (v, u, 0);
	}
	dinic (); return 0;
}

飞行员配对方案问题 dinic

一开始也是建图二分图上跑dinic，和模板唯一不同的就是需要输出两两匹配的方案。
思路：先排除与超级源点和超级汇点相连的边，因为我们要的是二分图内部的边。
输出方案的话，看看这条边的反向边有没有流量，有流量就是启用了，输出这条边的两端点即可。
不用纠结顺序，有spj

Code：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
#define INF 999999999
#define MAXN 100010
using namespace std;

struct fls {
	int to, next, val;
}edge[MAXN << 1];

int head[MAXN << 1], q[MAXN], level[MAXN], n1, n2, S, T, t, w, cnt = 1, ans;

inline int read () {
	register int s = 0, w = 1;
	register char ch = getchar ();
	while (! isdigit (ch)) {if (ch == '-') w = -1; ch = getchar ();}
	while (isdigit (ch)) {s = (s << 3) + (s << 1) + (ch ^ 48); ch = getchar ();}
	return s * w;
}

inline void connect (int u, int v, int w) {
	edge[++cnt].to = v, edge[cnt].val = w, edge[cnt].next = head[u], head[u] = cnt;
}

inline bool BFS () {
	memset (level, -1, sizeof level);
	level[S] = 0, q[t = w = 1] = S;
	while (t <= w) {
		int now = q[t];
		for (register int i = head[now]; i; i = edge[i].next) {
			int v = edge[i].to;
			if (edge[i].val != 0 && level[v] == -1) {
				level[v] = level[now] + 1;
				q[++w] = v;
			}
		}
		t++;
	}
	if (level[T] == -1) return 0;
	return 1;
}

int DFS (int now, int flow) {
	int ret = flow; if (now == T) return flow;
	for (register int i = head[now]; i; i = edge[i].next) {
		int v = edge[i].to; if (ret <= 0) break;
		if (edge[i].val != 0 && level[now] + 1 == level[v]) {
			int o = DFS (v, min (ret, edge[i].val));
			ret -= o, edge[i].val -= o, edge[i ^ 1].val += o;
		}
	}
	return flow - ret;
}

void dinic () {
	while (BFS ()) ans += DFS (S, INF);
}

int main () {
	n1 = read (), n2 = read (), S = 0, T = n1 + n2 + 1;
	for (;;) {
		int u = read (), v = read ();
		if (u == -1 || v == -1) break;
		connect (u, v, 1), connect (v, u, 0);
	}
	for (register int i = 1; i <= n1; i++) connect (S, i, 1), connect (i, S, 0);
	for (register int i = n1 + 1; i <= n1 + n2; i++) connect (i, T, 1), connect (T, i, 0);
	dinic (); if (ans == 0) return puts ("No Solution"), 0;
	printf ("%d\n", ans);
	for (register int i = 2; i <= cnt; i += 2) {
		if (edge[i].to == S || edge[i ^ 1].to == S) continue;
		if (edge[i].to == T || edge[i ^ 1].to == T) continue;
		if (edge[i ^ 1].val != 0) printf ("%d %d\n", edge[i].to, edge[i ^ 1].to);
	}
	return 0;
}

【模板】最小费用最大流 费用流

按照题意连边，反向边流量为0，费用为原边相反数。
一直做 S P F A SPFA SPFA直到汇点 T T T没有新增流量（找不到新的增广路）了为止，统计入答案 maxflow &amp; mincost \text {maxflow~\&amp; mincost} maxflow & mincost
核心内容就是在 S P F A SPFA SPFA松弛操作时保存信息，具体操作是用pre[]数组记录路径（从哪个点来），last[]记录边。

Code：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
#define MAXN 100010
using namespace std;

struct fls {
	int to, next, dist, flow;
}edge[MAXN << 1];

int head[MAXN << 1], vis[MAXN], dist[MAXN], flow[MAXN], pre[MAXN], q[MAXN], last[MAXN];
int cnt = 1, n, m, S, T, maxflow, mincost, t, w;

inline int read () {
	register int s = 0, w = 1;
	register char ch = getchar ();
	while (! isdigit (ch)) {if (ch == '-') w = -1; ch = getchar ();}
	while (isdigit (ch)) {s = (s << 3) + (s << 1) + (ch ^ 48); ch = getchar ();}
	return s * w;
}

inline void connect (int u, int v, int w, int o) {
	edge[++cnt].to = v, edge[cnt].flow = w, edge[cnt].dist = o,
	edge[cnt].next = head[u], head[u] = cnt;
}

inline bool SPFA () {
	memset (dist, 0x3f3f3f3f, sizeof dist);
	memset (flow, 0x3f3f3f3f, sizeof flow);
	memset (vis, 0, sizeof vis);
	q[t = w = 1] = S, vis[S] = 1, dist[S] = 0, pre[T] = -1;
	while (t <= w) {
		int now = q[t];	t++; vis[now] = 0;
		for (register int i = head[now]; i; i = edge[i].next) {
			int v = edge[i].to;
			if (edge[i].flow > 0 && dist[v] > dist[now] + edge[i].dist) {
				dist[v] = dist[now] + edge[i].dist;
				pre[v] = now; last[v] = i;
				flow[v] = min (flow[now], edge[i].flow);
				if (! vis[v]) {
					vis[v] = 1; q[++w] = v;
				}
			}
		}
	}
	return pre[T] != -1;
}

void MCMF () {
	while (SPFA ()) {
		int now = T;
		maxflow += flow[now], mincost += flow[now] * dist[now];
		while (now != S) {
			edge[last[now]].flow -= flow[T];
			edge[last[now] ^ 1].flow += flow[T];
			now = pre[now];
		}
	}
	printf ("%d %d\n", maxflow, mincost);
}

int main () {
	n = read (), m = read (), S = read (), T = read ();
	for (register int i = 1; i <= m; i++) {
		int u = read (), v = read (), w = read (), o = read ();
		connect (u, v, w, o), connect (v, u, 0, -o);
	}
	MCMF ();
	return 0;
}

负载平衡问题 费用流

本题与[HAOI2008]糖果传递和均分纸牌模板一样
可以解绝对值方程组或贪心 O ( n ) O(n) O(n)解决，考虑费用流，令 a v e = ∑ i = 1 n a i n ave=\frac{\sum_{i=1}^n a_i}{n} ave=n∑i=1n​ai​​，即调整后每个节点的值。
建立源点与汇点，小于 a v e ave ave的需要流，于是连向汇点，大于 a v e ave ave的需要分流，于是从源点连向它。边的流量为与 a v e ave ave的差值，费用为0（因为是虚拟的）
环上的点与它左右两边的点均连边，流量无限，费用为1（可以随便你怎么流，而且流是要花费代价的）
注意环的处理。建完图套 M C M F MCMF MCMF即可

Code：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
#define INF 999999999
#define MAXN 100000
using namespace std;

struct fls {
	int to, next, flow, dist;
}edge[MAXN << 1];

bool vis[MAXN];
int head[MAXN << 1], dist[MAXN], flow[MAXN], pre[MAXN], q[MAXN], id[MAXN];
int a[MAXN], mincost, S, T, n, t, w, cnt = 1;

inline int read () {
	register int s = 0, w = 1;
	register char ch = getchar ();
	while (! isdigit (ch)) {if (ch == '-') w = -1; ch = getchar ();}
	while (isdigit (ch)) {s = (s << 3) + (s << 1) + (ch ^ 48); ch = getchar ();}
	return s * w;
}

inline void connect (int u, int v, int w, int o) {
	edge[++cnt].to = v, edge[cnt].flow = w, edge[cnt].dist = o,
	edge[cnt].next = head[u], head[u] = cnt;
}

inline bool SPFA () {
	memset (dist, 0x3f3f3f3f, sizeof dist);
	memset (flow, 0x3f3f3f3f, sizeof flow);
	memset (vis, 0, sizeof vis);
	q[t = w = 1] = S, vis[S] = 1, dist[S] = 0, pre[T] = -1;
	while (t <= w) {
		int now = q[t]; t++; vis[now] = 0;
		for (register int i = head[now]; i; i = edge[i].next) {
			int v = edge[i].to;
			if (edge[i].flow > 0 && dist[v] > dist[now] + edge[i].dist) {
				dist[v] = dist[now] + edge[i].dist,
				flow[v] = min (flow[now], edge[i].flow),
				pre[v] = now, id[v] = i;
				if (! vis[v]) {
					vis[v] = 1, q[++w] = v;
				}
			}
		}
	}
	return pre[T] != -1;
}

void MCMF () {
	while (SPFA ()) {
		mincost += dist[T] * flow[T];
		int now = T;
		while (now != S) {
			edge[id[now]].flow -= flow[T];
			edge[id[now] ^ 1].flow += flow[T];
			now = pre[now];
		}
	}
	printf ("%d\n", mincost);
}

int main () {
	n = read (), S = 0, T = n + 1; int sum = 0;
	for (register int i = 1; i <= n; i++) a[i] = read (), sum += a[i];
	int ave = sum / n;
	for (register int i = 1; i <= n; i++)
		if (a[i] <= ave) connect (i, T, ave - a[i], 0), connect (T, i, 0, 0);
		else connect (S, i, a[i] - ave, 0), connect (i, S, 0, 0);
	for (register int i = 2; i <= n; i++) {
		connect (i, i - 1, INF, 1), connect (i - 1, i, 0, -1),
		connect (i - 1, i, INF, 1), connect (i, i - 1, 0, -1);
	}
	connect (1, n, INF, 1), connect (n, 1, 0, -1),
	connect (n, 1, INF, 1), connect (1, n, 0, -1);
	MCMF (); return 0;
}

魔术球问题 dinic

又是可以贪心的题，考虑如何建图a
注意到柱子是无关紧要的，显然考虑在小球上面做文章
拆点是一个重要技巧，一个小球拆成两个点，分别连向源点和汇点。
球内如何连边？对于当前编号 n o w now now， i i i在 ( n o w , n o w ∗ 2 ) (\sqrt {now},\sqrt{now*2}) (now ​,now∗2 ​)内枚举，这样就可以直接找到形成完全平方数的小球， i 2 − n o w i^2-now i2−now向 n o w &lt; &lt; 1 ∣ 1 now&lt;&lt;1|1 now<<1∣1连边即可
如果某次dinic后发现没有新增的流（可以新放上去的小球）那么就新增一根柱子，柱子数大于n时退出。
dinic更新流量时，记录流向当前节点的是哪个点，最后从源点开始输出即可
我的F[]数组记录的是这个编号的小球有没有被放过，Fst[]数组记录的是这根柱子上的第一个球是什么

Code：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cctype>
#include <algorithm>
#define MAXN 100010
#define INF 999999999
using namespace std;

struct fls {
	int to, next, val;
}edge[MAXN << 1];

bool F[MAXN];
int head[MAXN << 1], pre[MAXN], vis[MAXN], level[MAXN], q[MAXN], Fst[MAXN];
int S = 100001, T = 100002, cnt = 1, n, tot, now, t, w;

inline int read () {
	register int s = 0, w = 1;
	register char ch = getchar ();
	while (! isdigit (ch)) {if (ch == '-') w = -1; ch = getchar ();}
	while (isdigit (ch)) {s = (s << 3) + (s << 1) + (ch ^ 48); ch = getchar ();}
	return s * w;
}

inline void connect (int u, int v, int w) {
	edge[++cnt].to = v, edge[cnt].val = w, edge[cnt].next = head[u], head[u] = cnt;
}

inline bool BFS () {
	memset (level, -1, sizeof level);
	q[t = w = 1] = S, level[S] = 0;
	while (t <= w) {
		int now = q[t];
		for (register int i = head[now]; i; i = edge[i].next) {
			int v = edge[i].to;
			if (edge[i].val != 0 && level[v] == -1) {
				level[v] = level[now] + 1;
				q[++w] = v;
			}
		}
		t++;
	}
	return (level[T] != -1);
}

int DFS (int now, int flow) {
	int ret = flow; if (now == T) return flow;
	for (register int i = head[now]; i; i = edge[i].next) {
		int v = edge[i].to; if (ret <= 0) break;
		if (edge[i].val != 0 && level[v] == level[now] + 1) {
			int o = DFS (v, min (ret, edge[i].val));
			ret -= o, edge[i].val -= o, edge[i ^ 1].val += o;
			if (o > 0) pre[now >> 1] = v >> 1;
		}
	}
	return flow - ret;
}

inline void dinic () {
	int ans = 0;
	while (BFS ()) ans += DFS (S, INF);
	if (! ans) Fst[++tot] = now;
}

int main () {
	n = read ();
	while (tot <= n) {
		now++;
		connect (S, now << 1, 1), connect (now << 1, S, 0),
		connect (now << 1 | 1, T, 1), connect (T, now << 1 | 1, 0);
		for (register int i = (int) sqrt (now) + 1; (i * i) < (now << 1); i++) {
			connect ((i * i - now) << 1, now << 1 | 1, 1);
			connect (now << 1 | 1, (i * i - now) << 1, 0);
		}
		dinic ();
	}
	printf ("%d\n", now - 1);
	for (register int i = 1; i <= n; i++)
		if (! F[Fst[i]]) {
			for (register int j = Fst[i]; j && j != T >> 1; j = pre[j]) {
				F[j] = 1, printf ("%d ", j);
			}
			puts ("");
		}
	return 0;
}
sleepyNick
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java-io流学习总结.doc
11-24
Java IO 流学习总结 Java IO 流是 Java 语言中最重要的 Input/Output 机制之一，通过流我们可以自由地控制文件、内存、IO 设备等数据的流向。流机制是 Java 及 C++中的一个重要机制。 一、什么是流？ 流是字节...
java-网络编程-io流-学习案例
02-25
通过这个案例，学习者可以深入理解Java网络编程的基本原理，掌握如何使用IO流进行数据交换，以及如何结合Swing创建功能丰富的图形界面。同时，这也是实践多线程编程的好机会，因为服务器需要同时处理多个客户端的...
网络编程学习计划
Ghost
09-11 999
1.Richard Stevens，TCP/IP Illustrated, Vol.1 / Vol.2 / Vol.3《 TCP/IP 详解 卷1：协议 》《 TCP/IP 详解 卷2：实现 》《 TCP/IP 详解 卷3：TCP事务协议、HTTP、NNTP和UNIX域协议 》2.Douglas E. Comer, Internetworking with TCP/IP , Vol.1 / Vol
网络学习计划——【LSA总结】
小宋不认输
07-20 548
下图是链路状态通告类型图 怎样保证LSA全部被学习？ R2对比自己和R1的LSA后，将自己没有的LSA生成一个请求列表，然后逐条发给R1，R1会生成一个重传列表，然后逐条回复LSA，R2每收到一个LSA后会在请求列表中删除该LSA信息，并发送LSU，R1回复LSACK并在重传列表中删除该条LSA。直到请求列表和重传列表都为空时，标志着从loading状态变为full状态。整个过程都是由主（master）来控制的。 LSA总结 描述一条LSA：1.LSA 类型...
网络学习计划——【OSPF协议】
小宋不认输
07-16 941
基础概念 OSPF ：开放式最短路径优先协议 （open shortest path first） 使用范围：IGP 协议算法特点： 链路状态型路由协议，SPF算法 （最短路径优先算法） 协议是否传递网络掩码：传递网络掩码 协议封装：基于IP协议封装（属于跨层封装），协议号（标识上层即传输层是什么协议）为 89 IP传输不可靠（辨别：1.确认重传 2.周期性传输）——OSPF选择的是确认重传机制 协议号标识上层是什么协议，eg：17号表示是上层即传...
网络安全学习计划
weixin_45139919的博客
05-28 2743
咸鱼要努力呀~ 2019.06–2020.01 为期八个月的学习计划 六月 web安全基础知识 七月 web安全漏洞及防御 八月 渗透测试基础知识 九月 渗透测试环境搭建 十月 渗透测试工具使用 十一月 信息收集与社工技巧 十二月 web渗透 ...
数据流图学习
bird_tp的博客
12-16 1532
数据流图或数据流程图（Data Flow Diagram），缩写为DFD 是什么： 数据流图是结构化分析方法中使用的工具,它以图形的方式描绘数据在系统中流动和处理的过程，由于它只反映系统必须完成的逻辑功能，所以它是一种功能模型，标志了一个系统的逻辑输入和逻辑输出，以及把逻辑输入转换逻辑输出所需的加工处理。 注意点： 数据流图不是传统的流程图或框图，数据流也不是控制流。数据流图是...
Java io流学习
hua226的博客
04-12 2万+
Java io 一、File 1.1 File类概述和构造方法 概述： 它是文件和目录路径名的抽象表示 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。 将来是要通过具体的操作把这个路径的内容转换为具体存在的。 方法名 说明 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的File实例 File(String parent,String child) 从父路径名字符串
迁移学习（Transfer）
热门推荐
sikh_0529的博客
09-15 9万+
迁移学习(Transfer Learning)是一种机器学习方法，就是把为任务 A 开发的模型作为初始点，重新使用在为任务 B 开发模型的过程中。迁移学习是通过从已学习的相关任务中转移知识来改进学习的新任务，虽然大多数机器学习算法都是为了解决单个任务而设计的，但是促进迁移学习的算法的开发是机器学习社区持续关注的话题。迁移学习对人类来说很常见，例如，我们可能会发现学习识别苹果可能有助于识别梨，或者学习弹奏电子琴可能有助于学习钢琴。
小白自学Java后端学习计划（附带学习视频）
理木客
03-08 4148
一、Java基础 java基础语法 集合 io 多线程 并发 反射 网络编程 注意：对于Java基础，其中集合和io是初学Java后端的时候最常用的，特别是集合。对于多线程、并发、反射和网络编程，初学后端的时候基本用不到，因为你初学的时候不会涉及到这么深的技术，当然不代表不需要会，如果你面试肯定还是要会的。 这里学习Java，建议学习Java8（windows下安装Java8并配置环境变量...
基于深度学习的短时交通流预测与优化
CSDNXUXIAOYAO的博客
02-13 1万+
基于深度学习的短时交通流预测与优化摘要第一章 背景介绍第二章 数据预处理与短时交通流量特性分析2.1 数据来源2.3 短时交通流特性分析2.3.1 基于K-means的差异性分析2.3.2 基于变化率趋势的时间邻近性分析2.3.3 基于相关系数的空间关联性分析2.3.4 基于天气因素的随机性分析2.4 短时交通流量预测结果评估指标第三章 基于时空关联的短时交通流预测3.1 基于时空关联LSTM的交通流预测模型框架3.2 实验设计与结果分析3.2.1 相关系数权重计算结果第四章 引入天气因素的短时交通流预测4
day2-网络安全学习笔记--流密码
scarlett1017的博客
09-03 2265
分组密码：将明文划分为更长的分组，比如64位、128位，将每个明文分组作为一个最小数据单元进行加密，通常得到与明文等长的密文分组。（1）当密钥流序列是真的具有均匀分布的饿随机序列的时候，在每一对称密钥K下加密消息的密钥流之间将没有任何的关联性，达到一次一密码的效果。（2）在实际应用中，真正的随机序列是不可能重复产生的，所以只能产生密码学意义上京嗯嗯安全的为随机密钥流。（3）流密码的加解密算法往往比较简单，比如明文或密钥流逐位异或，其安全性依赖于密钥流生成算法的强度。3、常见的流密码算法。
网络流算法PPT学习教案.pptx
10-01
在PPT学习教案中，每个页面可能详细讲解上述概念的一个方面，通过例题、图示和步骤解释，帮助学生深入理解网络流算法的原理和应用。通过这样的学习材料，学生可以逐步掌握如何运用这些算法解决实际问题，并提升解决...
网络流学习资料
09-08
网络流是一种在图论中的重要概念，特别是在计算机科学和运筹学...通过深入学习这个"网络流学习资料"，你将能够熟练掌握网络流的基本理论，并能够灵活运用到实际问题中，提升你在视频检索标注和其他相关领域的技术能力。
项目部年度员工培训计划.docx
07-13
项目部年度员工培训计划.docx
c的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txt
最新发布
07-13
cc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.txtc的项目案例.tx
营销策划 -猫人内衣品牌升级诊断方案.pptx
07-13
营销策划 -猫人内衣品牌升级诊断方案.pptx
项目施工日志.docx
07-13
项目施工日志.docx
制作一份python网络爬虫学习计划
03-27
学习网络爬虫的计划： 1. 学习Python基础知识：理解Python语言的基本概念，了解Python的数据类型、操作符、控制流程、函数等基础知识。 2. 学习网络协议：HTTP、TCP、IP等网络协议是网络爬虫编程的基础，需要掌握...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值