六根胡子

原创 2021-1 从文件构造无向图 邻接表 指定节点边数生成随机图 c++

必要的说明算法第四版 人民邮电出版社，原书是java实现节点内容只有一个整型数标识符ID，可以更清楚写typedef int ID邻接表采用链表数组，头插法耐人寻味的细节邻接表在java里这样写Bag<Integer>[] adj,我想c++至少有这几种方法：一、固定大小的数组list<int> adj[MAX_V];二、灵活的数组vector<list<int>> adj;三、指针，内存在堆vector<list<int&

原创 【一文吃透归并排序】基本归并·原地归并·自然归并 C++

不从整体开始切分，而是一开始把每一个元素当成一个列表，然后，自底向上地合并相邻的列表，重复利用开始的那张图。

原创 【迷宫问题】找出迷宫所有可能的路径C++

用栈实现迷宫问题，找出所有可达的路径。

原创 【顶配快速排序】CUTOFF配合三点中值法的三路划分

Robert Sedgewick 观察到，当序列较短时，快速排序引入的额外代价比较明显，此时插入排序反而更快。极端情况下，所有数字都相同，会发生N/2次不必要的交换，因为划分是平衡的，故总体性能还是O(NlgN)。一种抽样的方法是检查，头，尾巴，中间的元素，然后选出其中的中位数作为pivot，即可保证最短序列至少有一个元素。

原创 【Queue新技法】用双数组实现一个队列 C++

说明：记入队的列表为F(Front)，出队的队列为R(Rear)，那完整的队列。是O(N)，可只有几次，但O(1)出队操作却有N个，即均摊到每次出队操作上只有。如上图所示，左边是原来的队列，右边是翻转后的队列。，也叫循环缓冲区，如图灰色部分就是队列的内容。

原创 【二分查找】求解单调方程的解 C++实现

查找是否存在某一个值。可以先找中间，每次放弃一半，效率。注意，为了一般化单调递增函数或者数列，我们把。,单调递增，现在给一个正整数。最常见的，一个严格单调递增。

原创 【查找第K个元素】无需排序O(N)，八岁都能懂

O(n)效率实现中位数，第k大值的算法。

原创 八岁都能懂：BFS判断一个图是二分图

一个图用两种颜色涂（橙黄和橘绿），相邻节点不能同色，如下图，4与5相邻且同色，所以不是二分图。

原创 2021-07-18Bert

# coding=utf-8from __future__ import absolute_import, division, print_functionimport copyimport jsonimport mathimport siximport torchimport torch.nn as nnfrom torch.nn import CrossEntropyLossimport torch.nn.functional as Ffrom torch.nn.utils.r

原创 多行且每行不确定个数的数据读取 讨厌的换行和getline(）

实例31 2 5 6 81 2258 3 65 14读到换行符停止void init() { _read(N); getchar(); int t; _for(i, 0, N) { char ch = ' '; while (ch!='\n') { cin >> t; ch = getchar(); out(t); } }}字符串流void init() { _read(N); getchar();//必须去掉，否则会读到首

原创 修改数组 第十届蓝桥杯省赛C++A/研究生组

AcWing原题链接Ac code#include<vector>#include<cstring>#include<iostream>#include<string>#include<cmath>#include<algorithm>using namespace std;#define _for(i,from,to) for(int i=(from);i<(to);++i)//[from,to)#defi

原创 2021-1 索引优先队列 c++

原理背景：常见的，用例已经有了N个元素，且有多个平行数组。只需要把索引加入队列。如果有现成的结构体数组，只要一个关于索引的优先队列即可。注意到，只调整索引（一个整型数）要比交换结构体高效很多。索引优先队列，可理解为能够快速访问最小元素的数组（甚至是任意一部分子集的最小元素，只把这一部分加入队列就好）。API函数名功能void insert(int k,KEY key)插入元素key，并和索引k关联void change(int k,KEY key)将索引为k的值

原创 2021-1 加权有向图 最短路径 理论准备

定义最短路径：在一幅加权有向图中，从顶点s到顶点v的最短路径指的是所有s到t中路径权重的最小者。最短路径树：包含起点s到所有可达顶点的最短路径，s为根节点，树中的每条路径都是一条最短路径。最短路径的性质路径是定向的。 最短的路径必须遵循其边缘的方向。 权重不一定是距离。 几何直觉可能会有所帮助，但是边缘权重权重可能代表时间或成本。并非所有顶点都需要可达。 如果t不能从s到达，则根本没有路径，因此从s到t没有最短的路径。 负权重会带来并发症。假设边缘权重为正（或为零）。 最短路径通常很简单。

原创 2021-1 从文件构建图 加权有向边 加权有向图的构建 邻接表 c++

图构造对比加权无向图无权有向图无权无向图加权有向图[本文]API1 有向边的类2 加权有向图测试图实现1 有向边类#pragma once#include<iostream>using namespace std;#define out(x) cout<<x<<" "#define hh printf_s("\n")string intToStr(int n);string doubleToStr(double d);

原创 2021-1 并查集 c++

union_find APIUF(int n) 构造函数，初始化n个空间bool connected（int v, int w）判断是否连通int find（int p) 找到p所在集合的根void Union(int v,int w) 合并两个集合,大写首字母为了区别关键字union代码//UF.h#pragma once#include<vector>#include<iostream>using namespace std;class UF{pub

原创 2021-1 贪心算法 最小生成树 Kruskal算法 c++实现

基本原理基础定义点这里了解 最小生成树理论准备假定树有V个顶点，按照边的权重由小到大处理，将边加入到最小生成树中，且加入的边不会和已经加入的边构成环，直到树中含有V-1条边为止。黑色边为树，灰色为无用边，所有灰色和所有白色节点构成一个切分，右侧边按权重排序。几个关键按照权重排序边，用一条优先队列。合并森林中的两棵树并识别环，用并查集。用一条队列来保存树的各个边。实现不失重点的，先看如何写好 Kruskal算法 。并查集，优先队列等工具放在文末。#pragma once#inc

原创 2021-1 基于堆的优先队列 为Prim版本定制 c++

优先队列APIinsert(key k)插入节点KeydelMin() 返回最小节点的ID，并从队头删除find(int id) 在队列中查找指定ID的索引，找不到返回-1reduceTo(Key e) 将对象的关键值减小，后调整队列实现c++#pragma once#include<queue>#include<iostream>#include<map>using namespace std;class minEdge{public:

原创 2021-1 最小生成树 Prim算法的即时实现 c++

思路要改进 Prim延时版本，可以尝试从队列中删除失效边（两个顶点都已在MST的边），但其实还可以删除更多的边。

原创 2021-1 最小生成树 Prim算法的延时版本 c++

基本原理关于横切边和切分定理，点这里 最小生成树理论准备树中的边是黑色加粗，红色边为横切边，加粗红色为最短横切边，也是将要加入最小生成树的边。解决三个问题最短横切边怎么找？用一条优先队列MinPQ来根据权重比较所有边如何保存切分？通过索引的布尔数组marked，标记已经加入树的节点（白色集合），自己的补集为灰色集合，两者构成一个切分。如何保存树？法一，通过一个队列mst保存最小生成树所有边法二，用一个父亲数组记录边，例如，edgeTo[v]记录着将v连入树中的Edge对象

原创 2021-1最小生成树理论准备

MST定义图的生成树：含有全部顶点的无环连通子图加权图的最小生成树MST: 权值最小的生成树一些约定只考虑连通图。至于非联通的图，将所有联通分量的最小生成树构成最小生成森林，换句话说不连通的没有最小生成树。边的权重不一定表示距离，短边也可能有高权重。边的权重可能是0或者负数。如果要求全为正数，将最小生成树定义为连接所有顶点且总权重最小的子图就够了。所有边的权重不同，权重不同树就一棵，反之不然。切分定理树的两个性质：连接任意两个节点都会产生一个新的环，加边成环。删去任意一条边都会

原创 2021-1 从文件构建图 加权边API 加权无向图API c++

有权边API用法提示：得到一条边edge的两个顶点，这样用：int v=edge.either(); int w=edge.other(v);c++实现//Edge.h#pragma once#include<iostream>#include<fstream>#include<string>using namespace std;#define out(data) cout<<data<<" "#define hh p

原创 2021-1 基于队列的拓扑排序 c++

理论准备优先级的调度问题，做饭先烧水，切菜先买菜，炒菜先放油，活动之间有先后限制关系。把必须先准备的事放到前面，需要大量铺垫的活动放到后面，得到一个序列就是拓扑排列。拓扑排序不唯一算法依次拿掉入度（指向自己的箭头个数）为零的节点（起点），并把起点的邻接点的入度减一。重复以上操作，直到不存在入度为零的点（起点）。如果最后仍然剩余节点，说明图中必然有环。准备：图的度数类APIDegrees（Digraph G） 构造函数int indegree（int v）v的入度int ou

原创 2021-1 计算强连通分量的个数 Kosaraju算法 c++

强连通分量的API理论准备点这里实现#pragma once#include"Digraph.h"#include"DepthFirstOrder.h"class KoarajuSCC{public: KoarajuSCC(Digraph& G); int count() { return m_count; } bool stronglyConnected(int v, int w) { return (*m_id)[v] == (*m_id)[w]; } in

原创 2021-1 找出图中强连通分量 理论准备

必要概念如果两个顶点是相互可达的，那么他们是强连通的。如果一幅有向图中任意两个顶点都是相互连通的，那么这个有向图也是强连通的。两个顶点是强连通的当且仅当他们都在一个普通的环中。有向图的强连通性也是一种顶点之间的等价关系（自反、对称、传递）。作为一种等价关系，强连通性将所有的顶点分成一些等价类，每个等价类都是由互为强连通的顶点的最大子集组成的，这些子集被称为强联通分量。一个含有N个顶点的有向图，如果是有向无环图，那么他有N个强联通分量。如果是强连通图，那么他只有一个强联通分量。一般的，联通分量

原创 2021-1拓扑排序 c++

必要的准备有向无环图才有拓扑排序。问题，如果判断一个有向图是否有环？点这里拓扑排序的背后是约束关系，优先调度的问题首先被考虑。简单的，你应该先学习十进制数字再研究数论。问题，如何得到拓扑排序呢？点这里拓扑排序APITopologicalSort(Digraph G) 构造函数bool isDAG() 是有向无环图么stack<int>* order()拓扑有序的节点代码#pragma once#include"DirectedCycle.h"#include"De

原创 2021-1 拓扑排序的准备，深度优先搜索的三个顺序

DFS的特性每个顶点只会被访问一次将dfs()的参数保存在一个数据结构中就能访问到图中的所有顶点有用的三个顺序前序：递归之前，顶点加入队列 pre()后序：递归之后，顶点加入队列 post()逆后序：递归之后，顶点入栈 reversePost()//伪代码dfs(G ,v): pre.enqueue(v)//函数栈调用的先后次序 for each w in v.adj(): dfs(G,w) post.enqueue(v)//完成dfs的节点次序，先完成的在队头 reve

原创 2021-1 有向图 寻找有向环 c++实现

DirectedCycle APIDirectedCycle(Digraph G) 寻找有向环的构造函数bool hasCycle() G中是否含有有向环stack<int> cycle() 有向环中的所有顶点（如果存在的话）图解代码#pragma once#include<stack>#include"Digraph.h"class DirectedCycle{public: DirectedCycle(Digraph& G);

原创 2021-1 从文件构建有向图API 测试单点和多点可达 c++实现

API和无向图Graph.h比较，只改动了几个地方，一个翻转图，添加边时只是单向添加。代码//Digraph.h#pragma once#include<iostream>#include<list>#include<vector>#include<fstream>using namespace std;#define out(x) cout<<x<<" "#define hh printf_s("\n")

原创 2021-1 用符号作为顶点名的图的API c++实现

输入格式不需要知道边数，也没有直接给出顶点数。但是，通过两次扫描文件routes.txt，建立符号表 Sting -> id 从【机场名】找到标志符【ID】反向索引，从【ID】 找到【机场名】，即数组keys[]存储【ID】的无向图APISymbolGraph.h头文件见 Graph.h Paths.h#pragma once#include<map>#include<sstream> #include"Graph.h"#include

原创 2021-1 判断无向图是否有环 与 判断一个图是否是二分图 c++

判断是否有环采用dfs搜索，维护三个顶点信息，【上一个已访问节点，当前节点，下一个】。直接的，当【下一个】已经被标记且不是【上一个】，说明有环。因为，被标记节点【上一个】，【下一个】属于一个联通子图，即有路径相连。Cycle.h#pragma once#include"Graph.h"class Cycle{private: vector<int>* m_visited = nullptr; bool m_hasCycle = false; void dfs(Graph&am

原创 2021-1 无向图中v到w最短路径 与 连通子图的个数 c++

最短路径从指定起点s做广度优先搜索，总能找到一条从s到v的最短路径，O(V+E)。头文件 Paths.h#include"Paths.h"void findShortestPath(Graph& G, int s, int v) { Paths pathG(G, s);//默认广搜，下面打印最短路径 if (pathG.hasPathto(v)) { for (auto& w : pathG.pathTo(v)) { if (w == s) printf_s("%2d

原创 2021-1 查找图中单点路径Paths的API 深搜/广搜实现

给定一个起点和一幅图，搜索到目标点的路径方法在搜索过程中维护一个父亲数组，将当前节点记为他那些尚未标记的邻接节点的父亲，本质是一棵树。打印路径是从终点迭代找他的父亲，可以用栈存储，最后栈顶是起点，依次弹出就是路径。这里我采用了list的头插法，效果一样。Path.h#pragma once#include<queue>#include"Graph.h"/********************如无必要，勿增实体**********************/class Path

原创 2021-1 图处理算法search的API 深搜/广搜的实现

图搜索的API起点（source）简单记为s。如图marked()给出图中v和s有没有相连关系。深度优先搜索#pragma once#include"Graph.h"class depthFirstSearch{public: depthFirstSearch(Graph& G, int s); int count() { return m_count; } bool marked(int v) { return m_marked->at(v); }pri

原创 2021-01堆排序

//Heap.h#pragma once#include<vector>#include<iostream>using namespace std;enum HeapType{ Big, Small};enum ChildPos{ Left, Right};const int Invalid = -1;const size_t MAXSIZE = 200;class Heap {private: int m_type; int* m_a..

原创 2021-1 算法 堆排序 c++实现

伪代码调整堆{数组首地址，数组长度，当前要调整节点下标} 保存当前节点到temp 建立用来寻找最小值的下标idx，初始化为左孩子 WHILE idx 没到数组尾： 将当前值、左孩子、右孩子三者之中的最小值的下标给idx IF idx 没有变化： BREAK ELSE 用idx的值覆盖掉当前节点 把temp放到idx处注意到调整的前提是整体是堆结构，只有一个节点需要调整。过程..

原创 2021-01 算法 后缀表达式建立表达式树

## 伪代码FOR each char in string: IF char is num : new node(num), then push ptr into stack. ELSE IF char is Ops: get top-2 of stack as l、r, then new node(Ops,l,r), push ptr into stack. ...

原创 python4

原创 python03

原创 python02

原创 Python01