算法学习1

最新推荐文章于 2024-01-17 11:04:26 发布
最新推荐文章于 2024-01-17 11:04:26 发布
阅读量355 收藏 3
点赞数
分类专栏： 学习笔记 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lt405514623/article/details/123598241
版权

算法

1 快速排序

#include<iostream>
#pragma warning(disable:4996)
using namespace std; 
//快速排序
const int N = 1e6 + 10;
int n;
int q[N];
void quick_sort(int q[], int l, int r)
{
	if (l >= r) return;
	int x = q[l], i = l - 1, j = r + 1;
	while (i<j)
	{
		do i++; while (q[i] < x);
		do j--; while (q[j] > x);
		if (i < j)swap(q[i], q[j]);
	}
	quick_sort(q, l, j);
	quick_sort(q, j + 1, r);
}
int main()
{
	scanf("%d", &n);
	for (int i = 0; i < n; i++) scanf("%d", &q[i]);
	quick_sort(q, 0, n - 1);
	for (int i = 0; i < n; i++) printf("%d", q[i]);
	return 0；
}

2 归并排序

#include<iostream>
#pragma warning(disable:4996)
using namespace std; 
//归并排序
const int N = 1000010;
int n;
int q[N], tmp[N];
void merge_sort(int q[], int l, int r) {
  if(l>=r)return;
	int mid = l + r >> 1;
	merge_sort(q, l, mid), merge_sort(q, mid + 1, r);
	int k = 0, i = l, j = mid+1;
	while (i <= mid && j <=r) {
		if (q[i] < q[j])tmp[k++] = q[i++];
		else tmp[k++] = q[j++];
	}
	while (i <= mid) tmp[k++] = q[i++];
	while (j <= r) tmp[k++] = q[j++];
	for (i = l, j = 0; i <= r; i++, j++) q[i] = tmp[j];
}
int main()
{
	scanf("%d", &n);
	for (int i = 0; i < n; i++) scanf("%d", &q[i]);
	merge_sort(q, 0, n - 1);
	for (int i = 0; i < n; i++) printf("%d", q[i]);
	return 0；
}

3 二分查找

#include<iostream>
#pragma warning(disable:4996)
using namespace std; 
//二分查找
const int N = 100010;
int n, m;
int q[N];
int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 0; i < n; i++) scanf("%d", &q[i]);
	while (m--)
	{
		int x;
		scanf("%d", &x);
		int l = 0, r = n - 1;
		while (l < r)
		{
			int mid = l + r >> 1;
			if (q[mid] >= x)r = mid;
			else l = mid + 1;
		}
		if (q[l] != x) cout << "-1 -1" << endl;
		else
		{
			cout << l << ' ';
			int l = 0, r = n - 1;
			while (l<r)
			{
				int mid = l + r + 1 >> 1;
				if (q[mid] <= x)l = mid;
				else r = mid - 1;
			}
			cout << l << endl;
		}
	}

	return 0;
}

4 高精度加法

#include<iostream>
#pragma warning(disable:4996)
using namespace std; 
#include<vector>

const int N = 1E6 + 10;
// C=A+B
vector<int> add(vector<int>& A, vector<int>& B)
{
	vector<int>C;
	int t = 0;//进位
	for (int i = 0; i < A.size() || i < B.size(); i++)
	{
		if (i < A.size()) t += A[i];
		if (i < B.size())t += B[i];
		C.push_back(t % 10);
		t /= 10;
	}
	if (t) C.push_back(1);
	return C;
}
int main()
{
	string a, b;
	vector<int> A, B;
	cin >> a >> b; // a="123456"
	for (int i = a.size() - 1; i >= 0; i--)A.push_back(a[i] - '0'); //A=[6,5,4,3,2,1]
	for (int i = b.size() - 1; i >= 0; i--)B.push_back(b[i] - '0');
	auto C = add(A, B);

	for (int i = C.size() - 1; i >= 0; i--)printf("%d", C[i]);
	return 0;
}

5 高精度减法

#include<iostream>
#pragma warning(disable:4996)
using namespace std; 
#include<vector>

//判断是否有A>=B
bool cmp(vector<int>& A, vector<int>& B)
{
	if (A.size() != B.size()) return A.size() >= B.size();
	for (int i = A.size() - 1; i >= 0; i--)
		if (A[i] != B[i])
			return A[i] > B[i];
	return true;
}
// C=A-B
vector<int> sub(vector<int>& A, vector<int>& B)
{
	vector<int>C;
	for (int i = 0, t = 0; i < A.size(); i++)
	{
		t = A[i] - t;
		if (i < B.size()) t -= B[i];
		C.push_back((t + 10) % 10);
		if (t < 0)t = 1;
		else t = 0;
	}
	while (C.size() > 1 && C.back() == 0) C.pop_back(); //去掉前导零
	return C;
}
int main()
{
	string a, b;
	vector<int> A, B;
	cin >> a >> b; // a="123456"
	for (int i = a.size() - 1; i >= 0; i--)A.push_back(a[i] - '0'); //A=[6,5,4,3,2,1]
	for (int i = b.size() - 1; i >= 0; i--)B.push_back(b[i] - '0');
	
	if (cmp(A, B))
	{
		auto C = sub(A, B);
		for (int i = C.size() - 1; i >= 0; i--)printf("%d", C[i]);
	}
	else
	{
		auto C = sub(B, A);
		printf("-");
		for (int i = C.size() - 1; i >= 0; i--)printf("%d", C[i]);
	}
	
	return 0;
}

6 高精度乘法

#include<iostream>
#pragma warning(disable:4996)
using namespace std; 
#include<vector>

vector<int>mul(vector<int>& A, int b)
{
	vector<int>C;
	int t = 0;//进位
	for (int i = 0; i < A.size() || t; i++)
	{
		if (i < A.size()) t += A[i] * b;
		C.push_back(t % 10);
		t /= 10;
	}
	return C;
}
int main()
{
	string a;
	int b;
	cin >> a >> b;
	vector<int>A;
	for (int i = a.size() - 1; i >= 0; i--) A.push_back(a[i] - '0');
	auto C = mul(A, b);
	for (int i = C.size() - 1; i >= 0; i--)printf("%d", C[i]);
	
	
	return 0;
}

7 高精度除法

#include<iostream>
#pragma warning(disable:4996)
using namespace std; 
#include<vector>

// A/b 商是C，余数是r
vector<int>div(vector<int>& A, int b,int &r)
{
	vector<int>C;
	r = 0;
	for (int i = A.size() - 1; i >= 0; i--)
	{
		r = r * 10 + A[i];
		C.push_back(r / b);
		r %= b;
	}
	reverse(C.begin(), C.end());
	while (C.size() > 1 && C.back() == 0) C.pop_back();
	
	return C;
}
int main()
{
	string a;
	int b;
	cin >> a >> b;
	vector<int>A;
	for (int i = a.size() - 1; i >= 0; i--) A.push_back(a[i] - '0');
	int r;
	auto C = div(A, b,r);
	for (int i = C.size() - 1; i >= 0; i--)printf("%d", C[i]);
	cout << endl << r << endl;
	
	
	return 0;
}

8 前缀和

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>

const int N=100010;
int n, m;
int S[N];

int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) scanf("%d", &S[i]);
	for (int i = 1; i <=n; i++) S[i] += S[i - 1] ;
	while (m--) {
		int l, r;
		scanf("%d%d", &l, &r);
		printf("%d\n", S[r] - S[l - 1]);
	}

	return 0;
}

9 子矩阵的和

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>

const int N=1010;
int n, m,q;
int a[N][N], S[N][N];

int main()
{
	scanf("%d%d%d", &n, &m, &q);
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
			scanf("%d", &a[i][j]);
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
			S[i][j] = S[i][j - 1] + S[i - 1][j] - S[i - 1][j - 1] + a[i][j];
	while (q--) {
		int x1, y1,x2,y2;
		scanf("%d%d%d%d", &x1, &y1,&x2,&y2);
		printf("%d\n", S[x2][y2] - S[x2][y1-1] - S[x1-1][y2] + S[x1-1][y1-1]);
	}
	return 0;
}

10 差分

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>

const int N=100010;
int n, m;
int b[N], a[N];

void insert(int l, int r, int c)
{
	b[l] += c;
	b[r + 1] -= c;
}

int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++)
		scanf("%d", &a[i]);
	for (int i = 1; i <= n; i++)
		insert(i, i, a[i]);
	while (m--)
	{
		int l,r,c;
		scanf("%d%d%d",&l,&r,&c);
		insert(l, r, c);
	}
	for (int i = 1; i <= n; i++) b[i] += b[i - 1];
	for (int i = 1; i <= n; i++)printf("%d", b[i]);
	return 0;
}

11 差分矩阵

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>

const int N = 1010;
int n, m;
int a[N][N], b[N][N];

void insert(int x1, int y1, int x2, int y2, int c) {
	b[x1][y1] += c;
	b[x1][y2 + 1] -= c;
	b[x2+1][y1 ] -= c;
	b[x2 + 1][y2 + 1] += c;
}

int main()
{
	int q;
	scanf("%d%d%d", &n, &m, &q);
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
			scanf("%d", &a[i][j]);
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
			insert(i, j, i, j, a[i][j]);
	while (q--) {
		int x1, y1, x2,y2,c;
		cin >> x1 >> y1 >> x2 >> y2 >> c;
		insert(x1, y1, x2, y2, c);
	}
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
			b[i][j] += b[i - 1][j] + b[i][j-1] - b[i - 1][j - 1];
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++)
			printf("%d", b[i][j]);
		puts(" ");
	}
	return 0;
}

12 最长连续不重复子序列

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>

const int N = 100010;
int a[N], S[N];
int n;

int main()
{
	
	cin >> n;
	for (int i = 0; i < n; i++) cin >> a[i];
	int res = 0;
	for (int i = 0, j = 0; i < n; i++) {
		S[a[i]]++;
		while (S[a[i]] > 1) {
			S[a[j]]--;
			j++;
		}
		res = max(res, i - j + 1);
	}
	cout << res << endl;
	return 0;
}

13 二进制中1的个数

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>

int lowbit(int x)
{
	return x & -x;//-x二进制为~x+1， x=1010,~x=0101,~x=1=0110;
}

int main()
{
	int n;
	cin >> n;
	while (n--) {
		int x;
		cin >> x;
		int res = 0;
		while (x) x -= lowbit(x), res++;//每次减去x的最后一位1

		cout << res << endl;
	}
	return 0;
	
	return 0;
}

14 离散化（区间和）

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
const int N = 300010;
int n, m;
int a[N], s[N];
typedef pair<int, int> PII;
vector<int>alls;
vector<PII>add, query;

int find(int x) {
	int l = 0, r = alls.size() - 1;
	while(l<r){
		int mid = l + r >> 1;
		if (alls[mid] >= x)r = mid;
		else l = mid + 1;
	}
	return r + 1; //离散映射从1开始；
}
int main()
{
	
	cin >> n >> m;
	for (int i = 0; i < n; i++) {
		int x, c;
		cin >> x >> c;
		add.push_back({ x, c });
		alls.push_back(x);
	}
	for (int i = 0; i < m; i++) {
		int l, r;
		cin >> l >> r;
		query.push_back({ l, r });
		alls.push_back(l);
		alls.push_back(r);
	}
	//去重
	sort(alls.begin(), alls.end());
	alls.erase(unique(alls.begin(), alls.end()), alls.end());
	//处理插入
	for (auto item : add) {
		int x = find(item.first);
		a[x] += item.second;
	}
	//预处理前缀和
	for (int i = 1; i <= alls.size(); i++)s[i] = s[i - 1] + a[i];
	//处理询问
	for (auto item : query) {
		int l = find(item.first);
		int r = find(item.second);
		cout << s[r] - s[l - 1] << endl;
	}
	return 0;
}

在这里插入图片描述

vector<int>::iterator unique(vector<int>& a) {
	int j = 0;
	for (int i = 0; i < a.size(); i++)
	{
		if (!i || a[i] != a[i - 1])
			a[j++] = a[i];
		//a[0] ~ a[j-1] 所有a中不重复的数
	}
	return a.begin() + j;
}

15 区间合并

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
const int N = 100010;
int n;
typedef pair<int, int> PII;
vector<PII>segs;
void merge(vector<PII>& segs) {
	vector<PII> res;
	int st = -2e9, ed = -2e9;
	for (auto seg : segs) {
		if (ed < seg.first) {
			if (st != -2e9) res.push_back({ st,ed });
			st = seg.first, ed = seg.second;
		}
		else ed = max(ed, seg.second);
	}
	if (st != -2e9)res.push_back({ st,ed });
	segs = res;
}
int main()
{
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		int l, r;
		cin >> l >> r;
		segs.push_back({ l,r });

	}
	merge(segs);
	cout << segs.size() << endl;
	
	return 0;
}

在这里插入图片描述

16 单链表

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

const int N = 10010;
//head表示头节点的下标
//e[i]表示节点i的值
//ne[i]表示节点i的next指针是多少
//idx存储当前已经用到了哪个点
int head, e[N], ne[N], idx;
//初始化
void init() {
	head = -1;
	idx = 0;
}
//将x插到头结点
void add_to_head(int x){
	e[idx] = x, ne[idx] = head, head = idx++;
}
//将x插到下标是k的点后面
void add(int k, int x) {
	e[idx] = x, ne[idx] = ne[k], ne[k] = idx++;
}
//将下标是k的点后面的点删掉
void remove(int k) {
	ne[k] = ne[ne[k]];
}
int main()
{
	int m;
	cin >> m;
	init();
	while (m--)
	{
		int k, x;
		char op;
		cin >> op;
		if (op == 'H')
		{
			cin >> x;
			add_to_head(x);
		}
		else if (op == 'D')
		{
			cin >> k;
			if (!k)head = ne[head];
			remove(k - 1);
		}
		else
		{
			cin >> k >> x;
			add(k - 1, x);
		}
	}
	for (int i = head; i != -1; i = ne[i])cout << e[i] << ' ';
	cout << endl;
	return 0;
	
}

在这里插入图片描述

17 双链表

const int N = 100010;

//e[]表示节点的值，l[]表示节点的左指针，r[]表示节点的右指针，idx表示当前用到了哪个节点
int e[N], l[N], r[N], idx;

//初始化
void init()
{
	//0是左端点，1是右端点
	r[0] = 1, l[1] = 0;
	idx = 2;
}
//在节点k的右边插入一个数x
void insert(int k, int x)
{
	e[idx] = x;
	r[idx] = r[k];
	l[idx] = k;
	l[r[k]] = idx;
	r[k] = idx++;
}
//删除节点a
void remove(int k)
{
	r[l[k]] = r[k];
	l[r[k]] = l[k];
}

18 模拟栈

// tt表示栈顶
int stk[N], tt = 0;

// 向栈顶插入一个数
stk[ ++ tt] = x;

// 从栈顶弹出一个数
tt -- ;

// 栈顶的值
stk[tt];

// 判断栈是否为空
if (tt > 0)
{

}

19 循环队列

// hh 表示队头，tt表示队尾的后一个位置
int q[N], hh = 0, tt = 0;

// 向队尾插入一个数
q[tt ++ ] = x;
if (tt == N) tt = 0;

// 从队头弹出一个数
hh ++ ;
if (hh == N) hh = 0;

// 队头的值
q[hh];

// 判断队列是否为空
if (hh != tt)
{

}

20 单调栈

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

const int N = 100010;
int stk[N], tt;
int main()
{
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		int x;
		scanf("%d", &x);
		while (tt && stk[tt] >= x)tt--;
		if (tt) printf("%d ", stk[tt]);
		else printf("-1 ");
		stk[++tt] = x;
	}



	return 0;
	
}

21 滑动窗口

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

const int N = 1000010;
int x, k,n;
int a[N], q[N];
int main()
{
	scanf("%d%d", &n, &k);
	for (int i = 0; i < n; i++)scanf("%d", &a[i]);
	int hh = 0, tt = -1;
	for (int i = 0; i < n; i++)
	{
		//判断队头是否已经滑出窗口
		while (tt >= hh && i - k + 1 > q[hh])hh++;
		while (tt >= hh && a[q[tt]] > a[i])tt--;
		q[++tt] = i;
		if(i>=k-1)printf("%d ", a[q[hh]]);
	}
	puts(" ");
	hh = 0, tt = -1;
	for (int i = 0; i < n; i++)
	{
		//判断队头是否已经滑出窗口
		while (tt >= hh && i - k + 1 > q[hh])hh++;
		while (tt >= hh && a[q[tt]] < a[i])tt--;
		q[++tt] = i;
		if(i>=k-1)printf("%d ", a[q[hh]]);
	}

	return 0;
	
}

在这里插入图片描述

22 kmp字符串

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

const int N = 10010, M = 100010;
int n, m;
char p[N], s[M];
int ne[N];
int main()
{
	cin >> n >> p + 1 >> m >> s + 1;//+1往后移动一位
	//求next的过程
	for (int i = 2, j = 0; i <= n; i++)
	{
		while (j && p[i] != p[j + 1]) j = ne[j];
		if (p[i] == p[j + 1])j++;
		ne[i] = j;
	}
	//kmp匹配过程
	for (int i = 1, j = 0; i <= m; i++)
	{
		while (j && s[i] != p[j + 1])j = ne[j];
		if (s[i] == p[j + 1])j++;
		if(j==n)
		{
			printf("%d ", i - n);//题目要求从零开始
			j = ne[j];
		}
	}
	return 0;
	
}

在这里插入图片描述

23 Trie字符串统计

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

const int N = 100010;

int son[N][26], cnt[N], idx;
char str[N];
//0号点既是根节点，又是空节点
//son[][]存储树中每个节点的子节点
//cnt[]存储以每个节点结尾的单词数量

void insert(char *str)
{
	int p = 0;
	for (int i = 0; str[i]; i++) {
		int u = str[i] - 'a';
		if (!son[p][u])son[p][u]=++idx;
		p = son[p][u];
	}
	cnt[p]++;
}
int query(char* str)
{
	int p = 0;
	for (int i = 0; str[i]; i++)
	{
		int u = str[i] - 'a';
		if (!son[p][u]) return 0;
		p = son[p][u];
	}
	return cnt[p];
}
int main()
{
	int n;
	scanf("%d", &n);
	while (n--)
	{
		char op[2];
		scanf("%s%s", op, str);
		if (op[0] == 'I')insert(str);
		else printf("%d\n", query(str));
	}
      	
	return 0;
	
}

在这里插入图片描述

24 合并集

在这里插入图片描述
在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

const int N = 100010;
int n, m;
int p[N];
int find(int x)//返回x的祖宗节点+路径压缩
{
	if (p[x] != x)p[x] = find(p[x]);
	return p[x];
}
int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) p[i] =  i;
	while (m--)
	{
		char op[2];
		int a, b;
		scanf("%s%d%d", op, &a, &b);
		if (op[0]== 'M')p[find(a)] = p[find(b)];
		else {
			if (find(a) == find(b)) puts("Yes");
			else puts("No");
		}
	}

      	
	return 0;
	
}

在这里插入图片描述

25 连通块中点的数量

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

const int N = 100010;
int n, m;
int p[N],sized[N];
int find(int x)//返回x的祖宗节点+路径压缩
{
	if (p[x] != x)p[x] = find(p[x]);
	return p[x];
}
int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		p[i] = i;
		sized[i] = 1;
	}
	while (m--)
	{
		char op[5];
		int a, b;
		scanf("%s", op);
		if (op[0] == 'C') {
			scanf("%d%d", &a, &b);
			if (find(a) == find(b))continue;
			sized[find(b)] += sized[find(a)];
			p[find(a)] = find(b);
		}
		else if(op[1]=='1')
		{
			scanf("%d%d", &a, &b);
			if (find(a) == find(b)) puts("Yes");
			else puts("No");
		}
		else
		{
			scanf("%d", &a);
			printf("%d\n", sized[find(a)]);
		}
	}

      	
	return 0;
	
}

在这里插入图片描述

26 推排序

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

const int N = 100010;
int n, m;
int h[N], sizee;

void down(int u)
{
	int t = u;
	if (2 * u <= sizee && h[2 * u] < h[t])t = 2 * u;
	if (2 * u + 1 <= sizee && h[2 * u + 1] < h[t])t = 2 * u + 1;
	if (u != t)
	{
		swap(h[u], h[t]);
		down(t);
	}
}
int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++)scanf("%d", &h[i]);
	sizee = n;
	for (int i = n / 2; i; i--)down(i);
	while(m--)
	{
		printf("%d ", h[1]);
		h[1] = h[sizee];
		sizee--;
		down(1);
	}

      	
	return 0;
	
}

在这里插入图片描述

27 模拟堆

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

const int N = 100010;
int n, m;
int h[N],ph[N],hp[N], sizee;
void heap_swap(int a, int b)
{
	swap(ph[hp[a]], ph[hp[b]]);
	swap(hp[a], hp[b]);
	swap(h[a], h[b]);
}
void down(int u)
{
	int t = u;
	if (2 * u <= sizee && h[2 * u] < h[t])t = 2 * u;
	if (2 * u + 1 <= sizee && h[2 * u + 1] < h[t])t = 2 * u + 1;
	if (u != t)
	{
		heap_swap(u, t);
		down(t);
	}
}
void up(int u)
{
	while (u / 2 && h[u / 2] > h[u])
	{
		heap_swap(u / 2, u);
		u /= 2;
	}
}
int main()
{
	int n, m = 0;
	scanf("%d", &n);
	while (n--)
	{
		char op[10];
		int k, x;
		scanf("%s", op);
		if (!strcmp(op, "I")) {
			scanf("%d", &x);
			sizee++;
			m++;
			ph[m] = sizee, hp[sizee] = m;
			h[sizee] = x;
			up(sizee);
		}
		else if (!strcmp(op, "PM"))printf("%d\n", h[1]);
		else if (!strcmp(op, "DM"))
		{
			heap_swap(1, sizee);
			sizee--;
			down(1);
		}
		else if (!strcmp(op, "D"))
		{
			scanf(" %d", &k);
			k = ph[k];
			heap_swap(k, sizee);
			sizee--;
			down(k), up(k);
		}
		else
		{
			scanf("%d%d", &k, &x);
			k = ph[k];
			h[k] = x;
			down(k), up(k);
		}
	}
      	
	return 0;
	
}

在这里插入图片描述

28 模拟散列表

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
const int N = 100003;
int h[N], e[N], ne[N],idx;
//拉链法
void insert(int x)
{
	int k = (x % N + N) % N;
	e[idx] = x;
	ne[idx] = h[k];
	h[k] = idx++;
	
}
bool find(int x)
{
	int k = (x % N + N) % N;
	for (int i = h[k]; i != -1; i = ne[i])
		if (e[i] == x)
			return true;
	return false;
	
}

int main()
{
	int n;
	scanf("%d", &n);
	memset(h, -1, sizeof h);
	while (n--)
	{
		char op[2];
		int x;
		scanf("%s%d", op, &x);
		if (*op == 'I')insert(x);
		else
		{
			if (find(x))puts("Yes");
			else puts("No");
		}
	}
	return 0;
	
}

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
const int N = 200003,null=0x3f3f3f3f;//开2~3倍
int h[N];
//开放寻址法
int find(int x)
{
	int k = (x % N + N) % N;
	while (h[k] != null && h[k] != x)
	{
		k++;
		if (k == N)k = 0;
	}
	return k;
}
int main()
{
	int n;
	scanf("%d", &n);
	memset(h, 0x3f, sizeof h);//按字节来memset，int有四个字节
	while (n--)
	{
		char op[2];
		int x;
		scanf("%s%d", op, &x);
		int k = find(x);
		if (*op == 'I')h[k] = x;
		else {
			if (h[k] != null)puts("Yes");
			else puts("No");
		}
	}
	return 0;
	
}

29 字符串哈希

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
const int N = 100010, P = 131;//经验
int n, m;
char str[N];
typedef unsigned long long ULL;//2^64
ULL p[N], h[N];

ULL get(int l, int r)
{
	return h[r] - h[l - 1] * p[r - l + 1];
}

int main()
{
	scanf("%d%d%s", &n, &m, str + 1);
	p[0] = 1;
	for (int i = 1; i <= n; i++)
	{
		p[i] = p[i - 1] * P;
		h[i] = h[i - 1] * P + str[i];

	}
	while (m--)
	{
		int l1, r1, l2, r2;
		scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
		if (get(l1, r1) == get(l2, r2))puts("Yes");
		else puts("No");
	}
	return 0;
	
}

在这里插入图片描述

30 排列数字

在这里插入图片描述

#include<vector>
#include<algorithm>
const int N = 1000001;
int n;
int path[N];
bool st[N];
//DFS
void dfs(int u)
{
	if (u == n)
	{
		for (int i = 0; i < n; i++)printf("%d", path[i]);
		puts("");
		return;
	}
	for (int i = 1; i <= n; i++)
	{
		if (!st[i])
		{
			path[u] = i;
			st[i] = true;
			dfs(u + 1);
			st[i] = false;
		}
	}
}

int main()
{
	cin >> n;
	dfs(0);
	
	
	return 0;
	
}

在这里插入图片描述

31 n-皇后问题

在这里插入图片描述
在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
const int N = 20;
int n;
char g[N][N];
bool col[N], dg[N], udg[N];
//DFS
void dfs(int u)
{
	if (u == n)
	{
		for (int i = 0; i < n; i++)puts(g[i]);
		puts("");
		return;
	}
	for(int i=0;i<n;i++)
		if (!col[i] && !dg[u + i] && !udg[n - u + i])
		{
			g[u][i] = 'Q';
			col[i] = dg[u + i] = udg[n - u + i] = true;
			dfs(u + 1);
			col[i] = dg[u + i] = udg[n - u + i] = false;
			g[u][i] = '.';//剪枝
		}
}

int main()
{
	cin >> n;
	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++)
			g[i][j] = '.';
	
	dfs(0);
	
	
	return 0;
	
}

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//枚举
const int N = 20;
int n;
char g[N][N];
bool row[N],col[N], dg[N], udg[N];

void dfs(int x, int y, int s)
{
	if (y == n)y = 0, x++;
	if (x == n)
	{
		if (s == n)
		{
			for (int i = 0; i < n; i++)puts(g[i]);
			puts("");
		}
		return;
	}
	//不放皇后
	dfs(x, y + 1, s);
	//放皇后
	if (!row[x] && !col[y] && !dg[x + y] && !udg[x - y + n])
	{
		g[x][y] = 'Q';
		row[x] = col[y] = dg[x + y] = udg[x - y + n] = true;
		dfs(x, y + 1, s + 1);
		row[x] = col[y] = dg[x + y] = udg[x - y + n] = false;
		g[x][y] = '.';
	}

}
int main()
{
	cin >> n;
	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++)
			g[i][j] = '.';
	
	dfs(0,0,0);
	
	
	return 0;
	
}

32 走迷宫

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
typedef pair<int, int>PII;
const int N = 110;
int n, m;
int g[N][N];//地图
int d[N][N];//距离，初始-1为没到过
PII q[N * N];//地图中坐标点

int bfs()
{
	int hh = 0, tt = 0;
	q[0] = { 0,0 };
	memset(d, -1, sizeof d);
	d[0][0] = 0;
	int dx[4] = { -1,0,1,0 }, dy[4] = { 0,1,0,-1 };
	while (hh <=tt)
	{
		auto t = q[hh++];
		for (int i = 0; i < 4; i++)
		{
			int x = t.first + dx[i], y = t.second + dy[i];
			if (x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
			{
				d[x][y] = d[t.first][t.second] + 1;
				q[++tt] = { x,y };
			}
		}
	}
	return d[n - 1][m - 1];
}

int main()
{
	cin >> n >> m;
	for (int i = 0; i < n; i++)
		for (int j = 0; j < m; j++)
			cin >> g[i][j];
	cout << bfs() << endl;
	
	return 0;
	
}

在这里插入图片描述

33 树与图的存储

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//邻接表
const int N = 100010, M = N * 2;
int h[N], e[M], ne[M], idx;//idx是边

void add(int a, int b)//a指向b
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
int main()
{
	memset(h, -1, sizeof h);
	
	return 0;
	
}

34 树的重心

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
const int N = 100010, M = N * 2;

int n, m;
int h[N], e[M], ne[M], idx;
bool st[N];

int ans = N;
void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

//以u为根的子树中点的数量
int dfs(int u) //深度优先遍历
{
	st[u] = true;//标记一下，已经被搜过了

	int sum = 1, res = 0;//sum表示子树大小，res表示删除节点后每一个连通中点数最大值
	for (int i = h[u]; i != -1; i = ne[i])
	{
		int j = e[i];
		if (!st[j])
		{
			int s=dfs(j);
			res = max(res, s);
			sum += s;
		}
	}
	res = max(res, n - sum);
	ans = min(ans, res);

	return sum;
}
int main()
{
	cin >> n;
	memset(h, -1, sizeof h);
	for (int i = 0; i < n - 1; i++)
	{
		int a, b;
		cin >> a >> b;
		add(a, b), add(b, a);
		
	};
	dfs(1);
	cout << ans << endl;
	return 0;
	
}

在这里插入图片描述

35 搜索与图论

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
const int N= 100010;
int n, m;
int h[N], e[N], ne[N], idx;
int d[N], q[N];

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
int bfs()
{
	int hh = 0, tt = 0;
	q[0] = 1;
	memset(d, -1, sizeof d);
	d[1] = 0;
	while (hh <= tt)
	{
		int t = q[hh++];
		for (int i = h[t]; i != -1; i = ne[i])
		{
			int j = e[i];
			if (d[j] == -1)
			{
				d[j] = d[t] + 1;
				q[++tt] = j;
			}
		}
	}

	return d[n];
}
int main()
{
	cin >> n >> m;
	memset(h, -1, sizeof h);
	for (int i = 0; i < m; i++)
	{
		int a, b;
		cin >> a >> b;
		add(a, b);
	}
	cout << bfs() << endl;
	return 0;
	
}

在这里插入图片描述

36 有向图的拓扑排序

在这里插入图片描述

#pragma warning(disable:4996)
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//有向无环图也成称为拓扑图
const int N = 100010;
int n,m;
int h[N], e[N], ne[N], idx;
int q[N], d[N];//q[N]表示拓扑排序（入度都为0），d[N]表示各个点的入度。

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
bool topsort()
{
	int hh = 0, tt = -1;
	for (int i = 1; i <= n; i++)
	{
		if (!d[i])
			q[++tt] = i;
	}
	while (hh <= tt)
	{
		int t = q[hh++];
		for (int i = h[t]; i != -1; i = ne[i])
		{
			int j = e[i];
			d[j]--;
			if (d[j] == 0)q[++tt] = j;
		}
	}
	return tt == n - 1;//当q进去n个
}
int main()
{
	cin >> n >> m;
	memset(h, -1, sizeof h);
	for (int i = 0; i < m; i++)
	{
		int a, b;
		cin >> a >> b;
		add(a, b);
		d[b]++;
		
	}
	if (topsort())
	{
		for (int i = 0; i < n; i++)printf("%d ", q[i]);
		puts("");
	}
	else puts("-1");
	return 0;
	
}

在这里插入图片描述

37 Dijkstra求最短路

在这里插入图片描述## 37.1 朴素Dijkstra算法
在这里插入图片描述
在这里插入图片描述

#pragma warning(disable:4996)
#include<cstring>
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
const int N = 510;
int n, m;
int g[N][N];//邻接矩阵    稠密图（m~ n^2）用邻接矩阵，稀疏图用邻接表
int dist[N];
bool st[N];
int dijkstra()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	for (int i = 0; i < n; i++)
	{
		int t = -1;
		for (int j = 1; j <= n; j++)
			if (!st[j] && (t == -1 || dist[t] > dist[j]))
				t = j;
		st[t] = true;
		for (int j = 1; j <= n; j++)
			dist[j] = min(dist[j], dist[t] + g[t][j]);
	}
	if (dist[n] == 0x3f3f3f3f)return -1;
	return dist[n];
}
int main()
{
	scanf("%d%d", &n, &m);
	memset(g, 0x3f, sizeof g);
	while (m--)
	{
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		g[a][b] = min(g[a][b], c);
	}
	int t = dijkstra();
	printf("%d\n", t);
	return 0;
	
}

在这里插入图片描述

37.2 堆优化版的Dijkstra算法

在这里插入图片描述

#pragma warning(disable:4996)
#include<cstring>
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<queue>
const int N = 100010;
typedef pair<int, int> PII;
int n, m;
int h[N], e[N], ne[N], idx, w[N];
int dist[N];
bool st[N];
void add(int a, int b, int c)
{
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;

}
int dijkstra()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	priority_queue<PII, vector<PII>, greater<PII>>heap;
	heap.push({ 0,1 });
	while (heap.size())
	{
		auto t = heap.top();
		heap.pop();
		int ver = t.second, distance = t.first;
		if (st[ver])continue;
		str[ver] = true;
		for (int i = h[ver]; i != -1; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > distance + w[i])
			{
				dist[j] = distance + w[i];
				heap.push({ dist[j],j });
			}
		}
	}
	if (dist[n] == 0x3f3f3f3f)return -1;
	return dist[n];
}
int main()
{
	scanf("%d%d", &n, &m);
	memset(h, -1, sizeof h);
	while (m--)
	{
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		add(a,b,c);
	}
	int t = dijkstra();
	printf("%d\n", t);
	return 0;
	
}

在这里插入图片描述

38 有边数限制的最短路

在这里插入图片描述
在这里插入图片描述

#pragma warning(disable:4996)
#include<cstring>
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

const int N = 510, M = 10010;
int n, m, k;
int dist[N], backup[N];
struct Edge
{
	int a, b, w;
}edges[M];
int bellman_ford()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	for (int i = 0; i < k; i++)
	{
		memcpy(backup, dist, sizeof dist);
		for (int j = 0; j < m; j++)
		{
			int a = edges[j].a, b = edges[j].b, w = edges[j].w;
			dist[b] = min(dist[b], backup[a] + w);
		}
	}
	if (dist[n] > 0x3f3f3f3f / 2)return -1;//边权存在负数，正无穷加负权更新正无穷
	return dist[n];
}
int main()
{
	scanf("%d%d%d", &n, &m, &k);
	for(int i=0;i<m;i++)
	{
		int a, b, w;
		scanf("%d%d%d", &a, &b, &w);
		edges[i] = { a,b,w };
	}
	int t = bellman_ford();
	if (t == -1)puts("impossible");
	else printf("%d\n", t);
	return 0;
	
}

在这里插入图片描述

39 spfa求最短路

在这里插入图片描述

#pragma warning(disable:4996)
#include<cstring>
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<queue>
const int N = 100010;
typedef pair<int, int> PII;
int n, m;
int h[N], e[N], ne[N], idx, w[N];
int dist[N];
bool st[N];
void add(int a, int b, int c)
{
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;

}
int spfa()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	queue<int>q;
	q.push(1);
	st[1] = true;
	while (q.size())
	{
		int t = q.front();
		q.pop();
		st[t] = false;
		for (int i = h[t]; i != -1; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > dist[t] + w[i])
			{
				dist[j] = dist[t] + w[i];
				if (!st[j])
				{
					q.push(j);
					st[j] = true;
				}
			}
		}
	}
	if (dist[n] == 0x3f3f3f3f)return -1;
	return dist[n];
}
int main()
{
	scanf("%d%d", &n, &m);
	memset(h, -1, sizeof h);
	while (m--)
	{
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		add(a, b, c);
	}
	int t = spfa();
	if (t == -1)puts("impossible");
	else printf("%d\n", t);
	return 0;

}

在这里插入图片描述

40 spfa判断负环

在这里插入图片描述

#pragma warning(disable:4996)
#include<cstring>
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<queue>
const int N = 100010;
typedef pair<int, int> PII;
int n, m;
int h[N], e[N], ne[N], idx, w[N];
int dist[N],cnt[N];
bool st[N];
void add(int a, int b, int c)
{
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;

}
int spfa()
{
	queue<int>q;
	for (int i = 1; i <=n; i++)
	{
		st[i] = true;
		q.push(i);
	}
	while (q.size())
	{
		int t = q.front();
		q.pop();
		st[t] = false;
		for (int i = h[t]; i != -1; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > dist[t] + w[i])
			{
				dist[j] = dist[t] + w[i];
				cnt[j] = cnt[t] + 1;
				if (cnt[j] >= n)return true;
				if (!st[j])
				{
					q.push(j);
					st[j] = true;
				}
			}
		}
	}
	return false;
}
int main()
{
	scanf("%d%d", &n, &m);
	memset(h, -1, sizeof h);
	while (m--)
	{
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		add(a, b, c);
	}
	if (spfa())puts("yes");
	else puts("No");
	return 0;

}

在这里插入图片描述

41 Floyd求最短路

在这里插入图片描述

#pragma warning(disable:4996)
#include<cstring>
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

using namespace std;
const int N = 210, INF = 1e9;
int n, m, Q;
int d[N][N];
void floyd()
{
	for (int k = 1; k <= n; k++)
		for (int i = 1; i <= n; i++)
			for (int j = 1; j <= n; j++)
				d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
int main()
{
	scanf("%d%d%d", &n, &m, &Q);
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++)
			if (i == j)d[i][j] = 0;
			else d[i][j] = INF;
	while (m--)
	{
		int a,b,w;
		scanf("%d%d%d", &a, &b, &w);
		d[a][b] = min(d[a][b], w);
	}
	floyd();
	while (Q--)
	{
		int a, b;
		scanf("%d%d", &a, &b);
		if (d[a][b] > INF / 2)puts("impossible");
		else printf("%d\n", d[a][b]);
	}
	return 0;
}

在这里插入图片描述

42 Prim算法求最小生成树

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#pragma warning(disable:4996)
#include<cstring>
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
const int N = 510,INF=1e9;
int g[N][N];
int n, m;
int dist[N];
bool st[N];
int prim()
{
	memset(dist, 0x3f, sizeof dist);
	int res = 0;
	for (int i = 0; i <n; i++)
	{
		int t = -1;
		for (int j = 1; j <= n; j++)
			if (!st[j] && (t == -1 || dist[t] > dist[j]))
				t = j;
		if (i && dist[t] == INF)return INF;
		if (i)res += dist[t];
		for (int j = 1; j <= n; j++)dist[j] = min(dist[j], g[t][j]);
		st[t] = true;
	}
	return res;

}
int main()
{
	scanf("%d%d", &n, &m);
	memset(g, 0x3f, sizeof g);
	while (m--)
	{
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		g[a][b] = g[b][a] = min(g[a][b], c);
	}
	int t = prim();
	if (t == INF)puts("impossible");
	else printf("%d\n", t);
	return 0;
}

在这里插入图片描述

43 Kruskal算法求最小生成树

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#pragma warning(disable:4996)
#include<cstring>
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
const int N = 200010;
int n, m;
int p[N];
struct Edge
{
	int a, b, w;
	bool operator<(const Edge& W)const
	{
		return w < W.w;
	}
}edges[N];
int find(int x)
{
	if (p[x] != x)p[x] = find(p[x]);
	return p[x];
}
int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 0; i < m; i++)
	{
		int a, b, w;
		scanf("%d%d%d", &a, &b, &w);
		edges[i] = { a,b,w };
	}
	sort(edges, edges + m);
	for (int i = 1; i <= n; i++)p[i] = i;
	int res = 0, cnt = 0;
	for (int i = 0; i <m; i++)
	{
		int a = edges[i].a, b = edges[i].b, w = edges[i].w;
		a = find(a), b = find(b);
		if (a != b)
		{
			p[a] = b;
			res += w;
			cnt++;
		}
	}
	if (cnt < n - 1)puts("impossible");
	else printf("%d\n", res);
	return 0;
}

44 染色体判定二分图

在这里插入图片描述
在这里插入图片描述

#pragma warning(disable:4996)
#include<cstring>
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
const int N = 100010,M=200010;
int n, m;
int h[N],e[M],ne[M],idx;
int color[N];
void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
bool dfs(int u, int c)
{
	color[u] = c;
	for (int i = h[u]; i != -1; i = ne[i])
	{
		int j = e[i];
		if (!color[j])
		{
			if (!dfs(j, 3 - c))return false;
		}
		else if (color[j] == c)return false;
	}
	return true;
}
int main()
{
	scanf("%d%d", &n, &m);
	memset(h, -1, sizeof h);
	while (m--)
	{
		int a, b;
		scanf("%d%d", &a, &b);
		add(a, b), add(b, a);
	}
	bool flag = true;
	for(int i=1;i<=n;i++)
		if (!color[i])
		{
			if (!dfs(i,1))
			{
				flag = false;
				break;
			}
		}
	if (flag)puts("Yes");
	else puts("No");
	return 0;
}

在这里插入图片描述

45 二分图的最大匹配

在这里插入图片描述

#include<cstring>
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
//匈牙利算法（找对象）
const int N = 510, M = 100010;
int n1, n2, m;
int h[N], e[M], ne[M], idx;
int match[N];//右边匹配
bool st[N];//每次不要重复搜一个点
void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
bool find(int x)
{
	for (int i = h[x]; i != -1; i = ne[i])
	{
		int j = e[i];
		if (!st[j])
		{
			st[j] = true;
			if (match[j] == 0 || find(match[j]))
			{
				match[j] = x;
				return true;
			}
		}
	}
	return false;
}
int main()
{
	scanf("%d%d%d", &n1, &n2, &m);
	memset(h, -1, sizeof h);
	while (m--)
	{
		int a, b;
		scanf("%d%d", &a, &b);
		add(a, b);
	}
	int res = 0;
	for (int i = 1; i <= n1; i++)
	{
		memset(st, false, sizeof st);
		if (find(i))res++;
	}
	printf("%d\n", res);
	return 0;
}

在这里插入图片描述

摸鱼儿Tao
关注
专栏目录
遗传算法与深度学习实战（1）——进化深度学习
盼小辉丶的博客
07-25 7547
进化深度学习 (Evolutionary Deep Learning, EDL) 是一套可以用于自动化深度学习系统开发的工具和实践，EDL 包括了广泛的进化计算方法和模式，可以应用于深度学习系统流程的各个方面。本节中，介绍了深度学习面临的挑战，以及进化深度学习在应对这些挑战方面的技术方法。
快速排序代码
m0_61693002的博客
11-16 456
一个排序的模板。 #include<iostream> using namespace std; const int N = 1e6 + 10; int n; int q[N]; void quick_sort(int q[], int l, int r) { if (l >= r)return; int x = q[r], i = l - 1, j = r + 1; //边界问题： //假如此时的q[r]是q[l]，会出现一个死循环，可以用数列1...
c语言代码大全和详细解释_【C++ 快速排序】非常简洁的代码模版（附：详细解释）
weixin_39906245的博客
11-28 915
快速排序步骤确定分界点x（q[l]或q[r]）调整区间（一段元素都，另一段元素都）递归左右两端核心模版void 说明一：当分界点选择x = q[l] 涉及到了左边界，所以递归必须写成quick_sort(q, l, j), quick_sort(q, j + 1, r);形式如果写成此时写成了quick_sort(q, l, i - 1), quick_sort(q, i, r);那么可能会出现死...
算法基础课学习记录
wrr66的博客
03-22 74
快速排序最大的问题是边界问题，如何合理的理解和分析边界是这道题的重点。归并排序与快排都是运用分治思想的一个排序算法，归并相对于快排更加稳定，当然，理解重点同样是边界问题。二分作为常见的做题思路，在做题过程中会经常遇到。二分可以分为整数二分与浮点数二分，由于整数不能被完美的分成两个部分，所以对于整数二分的边界处理也是最重点理解的地方。
acwing 快速排序
yywxq_的博客
10-22 123
基本思路：先找一个数组中的值x（最好找中间，不然会有边界问题），然后利用双指针不断向中间靠拢，左指针如遇到大于x的值则停下，右指针若遇到小于x的值则停下，然后交换两数，重复该操作直到两指针相遇，最后递归，不断缩小范围，最后输出。//此处不可换成kp( q , l , i );
快速排序算法的证明与边界分析
nwpu2015302463的博客
09-13 369
算法证明 算法证明使用算法导论里的循环不变式方法 快排模板(以j为分界) 快排属于分治算法，分治算法都有三步： 分成子问题 递归处理子问题 子问题合并 void quick_sort(int q[], int l, int r) { //递归的终止情况 if(l >= r) return; //第一步：分成子问题 int i = l - 1, j = r + 1, x = q[l + r >> 1]; while(i < j) {
1.机器学习-机器学习算法分类概述
最新发布
weixin_50804299的博客
01-17 8221
监督学习是机器学习中最常用的一种重要方法，它利用一组已知类别的样本调整分类器的参数，使其达到所要求性能的过程。简单来说，监督学习就是从已有的标记数据中学习模型，然后利用这个模型对新的未知数据进行预测。 在监督学习中，每个样本都包含输入特征和对应的输出标签。 输入特征也称为特征向量，是一个可以描述样本特性的值； 输出标签通常是离散的类别标签或者连续的数值标签，用来表示样本所属的类别或者具有的属性。 通过训练，模型将学会从输入特征中预测出相应的输出标签。 监督学习的应用场景非常广泛，包括但不限于分类、回归、
深度学习基础算法梳理
lili1158的博客
10-28 4379
深度学习算法学习分享
机器学习常见算法
guguo666的博客
05-08 3448
1.KNN算法 kNN算法又称为k近邻分类(k-nearest neighbor classification)算法。是从训练集中找到和新数据最接近的k条记录，然后根据他们的主要分类来决定新数据的类别。 该算法涉及3个主要因素：训练集、距离或相似的衡量、k的大小。 #1.导入： 分类问题： from sklearn.neighbors import KNeighborsClassifier 回归问题： from sklearn.neighbors import KNeighborsRegressor
算法学习路线
SafeVidulInfo的博客
07-07 2243
算法学习是一条漫长而又苦涩的道路。之所以漫长，是因为有关算法的学习是无穷无尽的，如果你不想经历程序员的35岁之劫难，那就要不断地学习算法，提高自己的不可替代性。之所以是苦涩，是因为算法更像是数学题，对智力是有一定要求的，学习算法的过程中总是会质疑自己，相较于一些学会就能用的技术而言，算法学习进步又不是那么显而易见，但是又是每一个程序员必须经历的。 所以学习的方法很重要，在自己智力、自制力以及一些其他我们无法控制的因素都是固定的情况下，因为这些因素都很难改变，方法的好坏直接决定我们学习的效率。 废话不多说直接
深度学习——BP算法学习
weixin_46537710的博客
07-15 2722
一、什么是BP算法 BP算法是建立在BP神经网络（多层前馈网络）上的一种算法，它根据神经网络的路径进行一层一层的运算，这个运算包括信号的正向传播和误差的反向传播两部分。 二、BP算法重要组成部分 BP神经网络包含层与节点，每相邻两层实现全连接。而BP算法包含输入值、输出值、预期值、权值、偏倚（充当阈值）。算法通过多次调整权值（神经元节点权系数）来实现在多组输入值情况下，输出值与预期值的逐渐拟合（即使两者间误差函数减小）。 误差函数 三、BP算法主要步骤 权系数修正公式如下： （1）输出层（Tk为输出
LeetCode 算法学习指南
fdl123456的博客
05-23 7305
本文来自微信公众号：labuladong 之前发的那篇关于 框架性思维 的文章，我也发到了不少其他圈子，受到了大家的普遍好评，这一点我真的没想到，首先感谢大家的认可，我会更加努力，写出通俗易懂的算法文章。 有很多朋友问我数据结构和算法到底该怎么学，尤其是很多朋友说自己是「小白」，感觉这些东西好难啊，就算看了之前的「框架思维」，也感觉自己刷题乏力，希望我能聊聊我从一个非科班小白一路是怎么学过来的。 ...
【PCL】激光雷达常用传统感知算法学习
DevFrank的博客
08-11 1749
激光雷达常用感知算法
算法基础集训（第01天）------＞【快速排序】：绝对是史上最全的快速排序分析，分析了所有的边界情况并给出算法可视化动图帮助你理解算法
mary19831的博客
08-02 648
排序问题可以说是最经典的算法问题了，一般一开始学的基础算法就是排序，排序既是算法的基础，也是考研数据结构的重要知识点。但是 C/C++ 都有现成的库函数（C里是 qsort、C++是sort），所以导致很多人就没有学排序算法本身，其实排序算法的思路非常有意思，从最简单的学起，对以后学习复杂算法是非常有帮助的，比如快速排序和快速选择之间的关系，归并排序和逆序对之间的关系。从今天开始，我们来试着掌握每个排序算法的思路，今天是快速排序。...........................
快速排序模板
小新的博客
11-01 152
void quick_sort(int q[],int l,int r){ if(l>=r) return; int x=q[l+r>>1],i=l-1,j=r+1; while(i<j){ do i++; while(q[i]<x); do j--; while(q[j]>x); if(i<j) swap(q[i],q[j]); } quick_sort(q,l,j); quick_sort(q,j+1,r);..
pytorch学习笔记
lt405514623的博客
11-21 1603
Pytorch学习1 加载数据初识2 TensorBorad的使用2.1 add_scalar()的使用2.1 add_image()的使用2.3 torchvision 中的transforms2.4 常见的Transforms2.4.1 ToTensor Normalize2.4.2 Resize Compose RandomCrop3 torchvision中的数据集使用4 DataLoader的使用5 神经网络的基本骨架-nn.Module的使用6 卷积操作7 神经网络卷积层 1 加
关于Python编程学习 类中出现的错误：TypeError：Dog（）takes no arguments
lt405514623的博客
01-07 1092
按照书本上的输入： 会显示出现错误： 经过多方查找资料，最终得到的正确输入：
8Python 学习笔记 最新 最详细
lt405514623的博客
01-17 907
8. 类 8.1创建Dog类 根据Dog类创建的每个实例都将存储名字和年龄，我们赋予了每条小狗蹲下（sit（））和打滚（roll_over())的能力： 第一行处定义了一个名为Dog的类。根据约定，在Python中，首字母大写的名称指的是类。这个类定义中没有圆括号，因为要从空白创建这个类。   方法_init_() 类中的函数称为方法。方法_init_()是一个特殊方法，每当你根据Dog类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和结尾各有两个下划线，这是一种约定，旨在避免Pyth
算法学习3
lt405514623的博客
05-03 517
算法01背包问题2 完全背包问题 01背包问题 #pragma warning(disable:4996) #include<cstring> #include<iostream> #include<unordered_set> using namespace std; const int N = 1010; int n, m; int v[N], w[N]; int f[N][N]; //f[i][j]表示[1,i]物品任取放入容量为j的背包 int main(
Python编程与算法学习笔记
"Python与算法基础知识点...这些知识点构成了Python编程和算法学习的基础，对于进一步探索机器学习和深度学习至关重要。通过学习这些内容，读者可以更好地理解Python程序的编写，掌握数据处理和算法应用的基本技巧。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值