Ninght9

图论模板，不定期更新

图论模板，随缘不定期更新

网络流
- 最大流
- - dinic（更新于2021/1/6）
  - hlpp（更新于2021/1/6）
- 最小费用最大流（更新于2021/1/6）
- 无源汇有上下界可行流（更新于2021/1/6）
- 有源汇上下界最大流（更新于2021/1/6）
最短路径
- dijkstra（更新于2021/1/6）
- spfa（更新于2021/1/6）
最小生成树
- kruskal（更新于2021/1/6）
- prim（更新于2021/1/6）
欧拉通路与欧拉回路
- 并查集（更新于2021/1/6）
- 判断存在欧拉回路（更新于2021/1/6）
- 寻找欧拉路径（更新于2021/1/6）
prufer编码
- prufer编码转树（更新于2021/1/6）
LCA（更新于2021/1/6）
tarjan求割点（更新于2021/1/6）

用来保存图论的模板方便备赛，算法的解析看心情写—Ninght

网络流

最大流

dinic（更新于2021/1/6）

//输入顶点数，边数，源点，汇点及各有向边的起始点和权值，输出汇点最大流
#include
#include
#include
#include
#define int long long
using std::queue;
struct node {
     
	int to;//终点
	int next;//与该边同起点的上一条边的序号
	int w;//权值
}qxx[200005];//边集链式前向星
int h[200005];//起点为x的一条边的序号
int cnt;//计数器
int n, m, st, en;//顶点数，边数，源点，汇点
int x, y, z;//始点，终点，权值
void add(int x, int y, int z) {
     
	qxx[++cnt] = node{
      y,h[x],z };
	h[x] = cnt;
}//添加边（始点，终点，权值）
void ad(int x, int y, int z) {
     
	add(x, y, z);//正向
	add(y, x, 0);//反向
}//添加边
int d[200005];
bool bfs() {
     
	memset(d, 0, sizeof d);
	queue<int>q;
	while (!q.empty())q.pop();
	d[st] = 1;
	q.push(st);
	while (!q.empty()) {
     
		int x = q.front();
		q.pop();
		for (int i = h[x]; i; i = qxx[i].next) {
     
			int v = qxx[i].to;
			if (!d[v] && qxx[i].w) {
     
				d[v] = d[x] + 1;
				q.push(v);
				if (v == en)return true;
			}
		}
	}
	return false;
}
int dfs(int u, int flow) {
     
	if (u == en)return flow;
	int rest = flow;
	for (int i = h[u]; i; i = qxx[i].next) {
     
		int v = qxx[i].to;
		if (d[v] == d[u] + 1 && qxx[i].w) {
     
			int tmp = dfs(v, std::min(qxx[i].w, rest));
			if (!tmp)d[v] = 0;
			rest -= tmp;
			qxx[i].w -= tmp;
			qxx[i ^ 1].w += tmp;
			if (!rest)break;
		}
	}
	return flow - rest;
}
int ans, sth;
signed main() {
     
	scanf_s("%lld%lld%lld%lld", &n, &m, &st, &en);
	for (int i = 1; i <= m; i++) {
     
		scanf_s("%lld%lld%lld", &x, &y, &z);
		ad(x, y, z);
	}
	while (bfs())while (sth = dfs(st, 1e9))ans += sth;
	printf("%lld", ans);
	return 0;
}

hlpp（更新于2021/1/6）

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define ll long long 
#define inf 0x3f3f3f3f
#define re register
#define il inline
using namespace std;
struct edge
{
     
    int to, next;
    int flow;
}a[2000020];//链式前向星 
int head[10010];
int gap[10010];//存储同层结点数
int h[10010];
int e[10010];//e[i]表示第i号节点的超额流
int vis[10010];
int cnt(0);
int n, m, st, ed;//顶点数，边数，源点，汇点
struct cmp
{
     
    il bool operator ()(int xi, int yi)const
    {
     
        return h[xi] < h[yi];
    }
};
priority_queue<int, vector<int>, cmp> pq;//以层数为优先级队列 
queue<int> q;
il void addedge(int xi, int yi, int fi)
{
     
    a[cnt].to = yi;
    a[cnt].next = head[xi];
    a[cnt].flow = fi;
    head[xi] = cnt++;
}
il bool bfs()
{
     
    re int i;
    memset(h + 1, inf, sizeof(int) * n);//将所有的节点高度均设为inf，表示不在网络内
    h[ed] = 0;
    q.push(ed);
    while (!q.empty())
    {
     
        int t = q.front();
        q.pop();
        for (i = head[t]; i != -1; i = a[i].next)
        {
     
            int v = a[i].to;
            if (a[i ^ 1].flow && h[v] > h[t] + 1)
            {
     
                h[v] = h[t] + 1;//更新节点高度
                q.push(v);
            }
        }
    }
    return h[st] != inf;
}
il void push(int u)
{
     
    re int i;
    for (i = head[u]; i != -1; i = a[i].next)//遍历当前点的邻点
    {
     
        int v = a[i].to;
        if ((a[i].flow) && (h[v] + 1 == h[u]))//将该店的超额流传入层数小1的邻点
        {
     
            int df = min(e[u], a[i].flow);
            a[i].flow -= df;
            a[i ^ 1].flow += df;
            e[u] -= df;
            e[v] += df;
            if ((v != st) && (v != ed) && (!vis[v]))
            {
     
                pq.push(v);
                vis[v] = 1;
            }
            if (!e[u])break;
        }
    }
}//只将处源点和汇点以外的点送入队列
il void relabel(int u)
{
     
    re int i;
    h[u] = inf;
    for (i = head[u]; i != -1; i = a[i].next)
    {
     
        int v = a[i].to;
        if ((a[i].flow) && (h[v] + 1 < h[u]))h[u] = h[v] + 1;
    }
}
inline int hlpp()
{
     
    re int i;
    if (!bfs())return 0;
    h[st] = n;
    memset(gap, 0, sizeof(int) * (n << 1));
    for (i = 1; i <= n; i++)if (h[i] != inf)gap[h[i]]++;
    for (i = head[st]; i != -1; i = a[i].next)
    {
     
        int v = a[i].to;
        if (int f = a[i].flow)
        {
     
            a[i].flow -= f; a[i ^ 1].flow += f;
            e[st] -= f; e[v] += f;
            if (v != st && v != ed && !vis[v])
            {
     
                ¬¬pq.push(v);
                vis[v] = 1;
            }
        }
    }
    while (!pq.empty())
    {
     
        int t = pq.top(); pq.pop();
        vis[t] = 0; push(t);
        if (e[t])
        {
     
            gap[h[t]]--;
            if (!gap[h[t]])
            {
     
                for (re int v = 1; v <= n; v++)
                {
     
                    if (v != st && v != ed && h[v] > h[t] && h[v] < n + 1)
                    {
     
                        h[v] = n + 1;
                    }
                }
            }
            relabel(t); gap[h[t]]++;
            pq.push(t); vis[t] = 1;
        }
    }
    return e[ed];
}
signed main()
{
     
    re int i;
    memset(head, -1, sizeof(head));
    scanf_s("%d%d%d%d", &n, &m, &st, &ed);
    for (i = 1; i <= m; i++)
    {
     
        int x, y;
        ll f;
        scanf_s("%d%d%lld", &x, &y, &f);
        addedge(x, y, f);
        addedge(y, x, 0);
    }
    ll maxf = hlpp();
    printf("%lld", maxf);
    return 0;
}

最小费用最大流（更新于2021/1/6）

#include
#include
#include
#include
using namespace std;
const int maxn = 100010;

bool vis[maxn];
int n, m, s, t, x, y, z, f, dis[maxn], pre[maxn], last[maxn], flow[maxn], maxflow, mincost;
//dis最小花费;pre每个点的前驱；last每个点的所连的前一条边；flow源点到此处的流量 
struct Edge {
     
	int to, next, flow, dis;//flow流量 dis花费 
}edge[maxn];
int head[maxn], num_edge;
queue <int> q;

void add_edge(int from, int to, int flow, int dis)
{
     
	edge[++num_edge].next = head[from];
	edge[num_edge].to = to;
	edge[num_edge].flow = flow;
	edge[num_edge].dis = dis;
	head[from] = num_edge;
}

bool spfa(int s, int t)
{
     
	memset(dis, 0x7f, sizeof(dis));
	memset(flow, 0x7f, sizeof(flow));
	memset(vis, 0, sizeof(vis));
	q.push(s); vis[s] = 1; dis[s] = 0; pre[t] = -1;

	while (!q.empty())
	{
     
		int now = q.front();
		q.pop();
		vis[now] = 0;
		for (int i = head[now]; i != -1; i = edge[i].next)
		{
     
			if (edge[i].flow > 0 && dis[edge[i].to] > dis[now] + edge[i].dis)//正边 
			{
     
				dis[edge[i].to] = dis[now] + edge[i].dis;
				pre[edge[i].to] = now;
				last[edge[i].to] = i;
				flow[edge[i].to] = min(flow[now], edge[i].flow);//
				if (!vis[edge[i].to])
				{
     
					vis[edge[i].to] = 1;
					q.push(edge[i].to);
				}
			}
		}
	}
	return pre[t] != -1;
}

void MCMF()
{
     
	while (spfa(s, t))
	{
     
		int now = t;
		maxflow += flow[t];
		mincost += flow[t] * dis[t];
		while (now != s)
		{
     //从源点一直回溯到汇点 
			edge[last[now]].flow -= flow[t];//flow和dis容易搞混 
			edge[last[now] ^ 1].flow += flow[t];
			now = pre[now];
		}
	}
}

int main()
{
     
	memset(head, -1, sizeof(head)); num_edge = -1;//初始化 
	scanf("%d%d%d%d", &n, &m, &s, &t);
	for (int i = 1; i <= m; i++)
	{
     
		scanf("%d%d%d%d", &x, &y, &z, &f);
		add_edge(x, y, z, f); add_edge(y, x, 0, -f);
		//反边的流量为0，花费是相反数 
	}
	MCMF();
	printf("%d %d", maxflow, mincost);
	return 0;
}

无源汇有上下界可行流（更新于2021/1/6）

#include
#include
#include
#include
#define N 100005
#define M 1000005
#define inf 1ll<<31ll-1
using namespace std;
int n, m, s, t, ss, tt, num = 1;
int v[M], w[M], next1[M];
int d[N], f[N], sum[N], first[N];
bool can[N];
void add(int x, int y, int f)
{
     
	num++;
	next1[num] = first[x];
	first[x] = num;
	v[num] = y;
	w[num] = f;
}
bool bfs(int start, int end)
{
     
	int x, y, i, j;
	memset(d, -1, sizeof(d));
	memcpy(f, first, sizeof(f));
	queue<int>q;
	q.push(start);
	d[start] = 0;
	while (!q.empty())
	{
     
		x = q.front();
		q.pop();
		for (i = first[x]; i; i = next1[i])
		{
     
			y = v[i];
			if (w[i] && d[y] == -1 && !can[y])
			{
     
				d[y] = d[x] + 1;
				if (y == end)
					return true;
				q.push(y);
			}
		}
	}
	return false;
}
int dinic(int now, int end, int flow)
{
     
	if (now == end)
		return flow;
	int x, delta, ans = 0;
	for (int& i = f[now]; i; i = next1[i])
	{
     
		x = v[i];
		if (w[i] && d[x] == d[now] + 1 && !can[x])
		{
     
			delta = dinic(x, end, min(flow, w[i]));
			w[i] -= delta;
			w[i ^ 1] += delta;
			flow -= delta;
			ans += delta;
			if (!flow)  break;
		}
	}
	if (flow)  d[now] = -1;
	return ans;
}
int main()
{
     
	int x, y, i, j, l, r;
	int ans = 0, maxflow = 0;
	scanf("%d%d%d%d", &n, &m, &s, &t);
	ss = 0, tt = n + 1;
	for (i = 1; i <= m; ++i)
	{
     
		scanf("%d%d%d%d", &x, &y, &l, &r);
		sum[x] -= l, sum[y] += l;
		add(x, y, r - l), add(y, x, 0);
	}
	for (i = 1; i <= n; ++i)
	{
     
		if (sum[i] > 0)  add(ss, i, sum[i]), add(i, ss, 0), ans += sum[i];
		if (sum[i] < 0)  add(i, tt, -sum[i]), add(tt, i, 0);
	}
	add(t, s, inf), add(s, t, 0);
	while (bfs(ss, tt))
		maxflow += dinic(ss, tt, inf);
	can[ss] = false;
	can[tt] = false;
	if (maxflow != ans)
	{
     
		printf("please go home to sleep");
		return 0;
	}
	int minflow = 0;
	add(t, s, -inf), add(s, t, 0);
	while (bfs(t, s))
		minflow -= dinic(t, s, inf);
	printf("%d", minflow);
	return 0;
}

有源汇上下界最大流（更新于2021/1/6）

#include
#include
#include
#include
#define N 100005
#define M 1000005
#define inf 1ll<<31ll-1
using namespace std;
int n, m, s, t, ss, tt, num = 1;
int v[M], w[M], next1[M];
int d[N], f[N], sum[N], first[N];
bool can[N];
void add(int x, int y, int f)
{
     
	num++;
	next1[num] = first[x];
	first[x] = num;
	v[num] = y;
	w[num] = f;
}
bool bfs(int start, int end)
{
     
	int x, y, i, j;
	memset(d, -1, sizeof(d));
	memcpy(f, first, sizeof(f));
	queue<int>q;
	q.push(start);
	d[start] = 0;
	while (!q.empty())
	{
     
		x = q.front();
		q.pop();
		for (i = first[x]; i; i = next1[i])
		{
     
			y = v[i];
			if (w[i] && d[y] == -1 && !can[y])
			{
     
				d[y] = d[x] + 1;
				if (y == end)
					return true;
				q.push(y);
			}
		}
	}
	return false;
}
int dinic(int now, int end, int flow)
{
     
	if (now == end)
		return flow;
	int x, delta, ans = 0;
	for (int& i = f[now]; i; i = next1[i])
	{
     
		x = v[i];
		if (w[i] && d[x] == d[now] + 1 && !can[x])
		{
     
			delta = dinic(x, end, min(flow, w[i]));
			w[i] -= delta;
			w[i ^ 1] += delta;
			flow -= delta;
			ans += delta;
			if (!flow)  break;
		}
	}
	if (flow)  d[now] = -1;
	return ans;
}
int main()
{
     
	int x, y, i, j, l, r;
	int ans = 0, maxflow = 0;
	scanf("%d%d%d%d", &n, &m, &s, &t);
	ss = 0, tt = n + 1;
	for (i = 1; i <= m; ++i)
	{
     
		scanf("%d%d%d%d", &x, &y, &l, &r);
		sum[x] -= l, sum[y] += l;
		add(x, y, r - l), add(y, x, 0);
	}
	for (i = 1; i <= n; ++i)
	{
     
		if (sum[i] > 0)  add(ss, i, sum[i]), add(i, ss, 0), ans += sum[i];
		if (sum[i] < 0)  add(i, tt, -sum[i]), add(tt, i, 0);
	}
	add(t, s, inf), add(s, t, 0);
	while (bfs(ss, tt))
		maxflow += dinic(ss, tt, inf);
	can[ss] = false;
	can[tt] = false;
	if (maxflow != ans)
	{
     
		printf("please go home to sleep");
		return 0;
	}
	maxflow = 0;
	while (bfs(s, t))
		maxflow += dinic(s, t, inf);
	printf("%d", maxflow);
	return 0;
}

最短路径

dijkstra（更新于2021/1/6）

#include
#include
#include
#define MAX 200020
#define inf 0x7fffffff
using namespace std;
int n, m,vis[MAX];
long long dis[MAX];
struct edgenode
{
     
	int to;
	int next;
	int weight;
}edge[MAX];
int  cnt, head[MAX];
int u, v, w;
int s;
struct node
{
     
	long long dis;
	int pos;
	bool operator <(const node& x)const
	{
     
		return x.dis < dis;
	}
};
std::priority_queue<node> q;//优先队列
void add_edge(int u, int v, int w);
void dijkstra();
int main()
{
     
	memset(dis, -1, sizeof(dis));
	scanf_s("%d%d%d", &n, &m, &s);
	for (int i = 1; i <= n; i++)dis[i] = inf;
	for (int i = 0; i < m; i++)
	{
     
		scanf_s("%d%d%d", &u, &v, &w);
		add_edge(u, v, w);
	}
	dijkstra();
	for (int i = 1; i <= n; i++)printf("%lld ", dis[i]);
}
void add_edge(int u, int v, int w)
{
     
	edge[++cnt] = edgenode{
      v,head[u],w };
	head[u] = cnt;
}
void dijkstra()
{
     
	dis[s] = 0;
	q.push(node {
      0, s });
	while (!q.empty())
	{
     
		node tmp = q.top();
		q.pop();
		int x = tmp.pos, d = tmp.dis;
		if (vis[x])
			continue;
		vis[x] = 1;
		for (int i = head[x]; i; i = edge[i].next)
		{
     
			int y = edge[i].to;
			if (dis[y] > dis[x] + edge[i].weight)
			{
     
				dis[y] = dis[x] + edge[i].weight;
				if (!vis[y])
				{
     
					q.push(node {
      dis[y], y });
				}
			}
		}
	}
}

spfa（更新于2021/1/6）

#include
#include
#include
#define MAX 200010
#define inf 2147483647
using namespace std;
int n, m, s;//点数，边数，出发点
int vis[MAX];
long long dis[MAX];
int head[MAX], cnt, u, v, w;
struct node
{
     
	int to;
	int next;
	int weight;
}edge[MAX];
void add_edge(int u, int v, int w);
void spfa();
int main()
{
     
	memset(head, -1, sizeof(head));
	scanf_s("%d%d%d", &n, &m, &s);
	for (int i = 0; i < m; i++)
	{
     
		scanf_s("%d%d%d", &u, &v, &w);
		add_edge(u, v, w);
	}
	spfa();
	for (int i = 1; i <= n; i++)
		if (i == s)printf("0 ");
		else printf("%lld ", dis[i]);

}
void add_edge(int u, int v, int w)
{
     
	edge[++cnt] = node{
      v,head[u],w };
	head[u] = cnt;
}
void spfa()
{
     
	queue<int> q; //spfa用队列，这里用了STL的标准队列
	for (int i = 1; i <= n; i++)
	{
     
		dis[i] = inf; //带权图初始化
		vis[i] = 0; //记录点i是否在队列中，同dijkstra算法中的visited数组
	}
	q.push(s); dis[s] = 0; vis[s] = 1; //第一个顶点入队，进行标记
	while (!q.empty())
	{
     
		int u = q.front(); //取出队首
		q.pop(); vis[u] = 0; //出队标记
		for (int i = head[u]; i!=-1; i = edge[i].next) //邻接表遍历7
		{
     
			int v = edge[i].to;
			if (dis[v] > dis[u] + edge[i].weight) //如果有最短路就更改
			{
     
				dis[v] = dis[u] + edge[i].weight;
				if (vis[v] == 0) //未入队则入队
				{
     
					vis[v] = 1; //标记入队
					q.push(v);
				}
			}
		}
	}
}

最小生成树

kruskal（更新于2021/1/6）

#include
#include
#include
using namespace std;

#define MAXN 11		//顶点个数的最大值
#define MAXM 20		//边的个数的最大值
struct edge			//边
{
     
	int u, v, w;
}edges[MAXM];		//边的数组
int parent[MAXN];	//parent[i]为顶点i所在集合对应的树中的根结点
int n, m;			//顶点个数、边的个数
int i, j;			//循环变量
void UFset()		//初始化 
{
     
	for (i = 1; i <= n; i++) parent[i] = -1;
}
int Find(int x)		//查找并返回结点x所属集合的根结点
{
     
	int s;			//查找位置
	for (s = x; parent[s] >= 0; s = parent[s]);
	while (s != x)	//优化方案——压缩路径，使后续的查找操作加速
	{
     
		int tmp = parent[x];
		parent[x] = s;
		x = tmp;
	}
	return s;
}
//运用并查集，将两个不同集合的元素进行合并，使两个集合中任意两个元素都连通
void Union(int R1, int R2)
{
     
	int r1 = Find(R1), r2 = Find(R2);		//r1和r2分别为R1和R2的根结点
	int tmp = parent[r1] + parent[r2];		//两个集合结点数之和（负数）
	//如果R2所在树结点个数 > R1所在树结点个数（注意parent[r1]是负数）
	if (parent[r1] > parent[r2])
	{
     
		parent[r1] = r2;
		parent[r2] = tmp;
	}
	else
	{
     
		parent[r2] = r1;
		parent[r1] = tmp;
	}
}
int cmp(const void* a, const void* b)		//实现从小到大的比较函数
{
     
	edge aa = *(const edge*)a, bb = *(const edge*)b;
	return aa.w - bb.w;
}
void Kruskal()
{
     
	int sumweight = 0;		//生成树的权值
	int num = 0;			//已选用的边的数目
	UFset();				//初始化parent数组
	for (i = 0; i < m; i++)
	{
     
		if (Find(edges[i].u) != Find(edges[i].v))
		{
     
			printf("%d %d %d\n", edges[i].u, edges[i].v, edges[i].w);
			sumweight += edges[i].w; num++;
			Union(edges[i].u, edges[i].v);
		}
		if (num >= n - 1) break;
	}
	printf("The weight of MST is : %d\n", sumweight);
}
void main()
{
     
	scanf("%d%d", &n, &m);	//读入顶点个数和边数
	for (int i = 0; i < m; i++)
		scanf("%d%d%d", &edges[i].u, &edges[i].v, &edges[i].w);	//读入边的起点和终点
	printf("The edges chosen are :\n");
	qsort(edges, m, sizeof(edges[0]), cmp);	//对边按权值从小到大排序
	Kruskal();
}

prim（更新于2021/1/6）

#include
#include
#include
#include
#include
using namespace std;
#define INF 0x3f3f3f3f
#define MAXN 110
int map[MAXN][MAXN], lowcost[MAXN];
bool visit[MAXN];
int nodenum, sum;

void prim()
{
     
	int temp, k;
	sum = 0;
	memset(visit, false, sizeof(visit)); //初始化visit
	visit[1] = true;
	for (int i = 1; i <= nodenum; ++i) //初始化lowcost[i]
		lowcost[i] = map[1][i];
	for (int i = 1; i <= nodenum; ++i)//找生成树集合点集相连最小权值的边
	{
     
		temp = INF;
		for (int j = 1; j <= nodenum; ++j)
			if (!visit[j] && temp > lowcost[j])
				temp = lowcost[k = j];
		if (temp == INF) break;
		visit[k] = true; //加入最小生成树集合
		sum += temp;//记录权值之和
		for (int j = 1; j <= nodenum; ++j) //更新lowcost数组
			if (!visit[j] && lowcost[j] > map[k][j])
				lowcost[j] = map[k][j];
	}
}

int main()
{
     
	int a, b, cost, edgenum;
	while (scanf("%d", &nodenum) && nodenum)//结点数
	{
     
		memset(map, INF, sizeof(map));
		edgenum = nodenum * (nodenum - 1) / 2;
		for (int i = 1; i <= edgenum; ++i) //输入边的信息
		{
     
			scanf("%d%d%d", &a, &b, &cost);
			if (cost < map[a][b])
				map[a][b] = map[b][a] = cost;
		}
		prim();
		printf("%d\n", sum); //最小生成树权值之和
	}
	return 0;
}

欧拉通路与欧拉回路

并查集（更新于2021/1/6）

#include 
#include
using namespace std;
const int maxn = 10002;
int n, m, a[maxn];
int Chaxun(int x)
{
     
    return (a[x] == x) ? x : a[x] = Chaxun(a[x]);
}

void Hebin(int x, int y)
{
     
    a[Chaxun(x)] = Chaxun(y);
}
int main()
{
     
    int i, x, y, z;
    scanf("%d%d", &n, &m);
    for (i = 1; i <= n; i++)a[i] = i;
    for (i = 0; i < m; i++)
    {
     
        scanf("%d%d%d", &z, &x, &y);
        if (z == 1)Hebin(x, y);
        if (z == 2)
        {
     
            if (Chaxun(x) == Chaxun(y))printf("Y\n");
            else printf("N\n");
        }
    }
    return 0;
}

判断存在欧拉回路（更新于2021/1/6）

#include 

int arr[1000];
int father[1000];
int rand_deep[1000];

int findSet(int x) {
     
	int px = x, i;
	while (px != father[px])
		px = father[px];
	//路径压缩，加快查找速度
	while (x != px) {
     
		i = father[x];
		father[x] = px;
		x = i;
	}
	return px;
}

void unionSet(int x, int y) {
     
	x = findSet(x);
	y = findSet(y);
	if (rand_deep[x] > rand_deep[y])
		father[y] = x;
	else {
     
		father[x] = y;
		if (rand_deep[x] == rand_deep[y])rand_deep[y]++;
	}
}
//并查集
int main() {
     
	int N, M;
	while (scanf("%d", &N) != EOF && N) {
     
		scanf("%d", &M);
		int i;
		int flag = 1;
		for (i = 1; i <= N; i++) {
     
			father[i] = i;
			rand_deep[i] = 0;
			arr[i] = 0;
		}
		for (i = 0; i < M; i++) {
     
			int x, y;
			scanf("%d %d", &x, &y);
			arr[x] ++;
			arr[y] ++;
			unionSet(x, y);
		}

		int father;
		for (i = 1; i <= N; i++) {
     
			if (i == 1)
				father = findSet(1);
			else {
     
				if (father != findSet(i)) {
     
					flag = 0;
					break;
				}
			}
			if (arr[i] == 0 || arr[i] % 2 != 0) {
     
				flag = 0;
				break;
			}
		}
		//判断是否在同一连通分量中
		printf("%d\n", flag);

	}
	return 0;
}

寻找欧拉路径（更新于2021/1/6）

#include
#include
#include
#include
#include
#include
using namespace std;

const int N = 1005;
int n, m, flag, top, sum, du[N], ans[5005], map[N][N];

void dfs(int x)
{
     
    ans[++top] = x;
    for (int i = 1; i <= n; i++)
    {
     
        if (map[x][i] >= 1)
        {
     
            map[x][i]--;
            map[i][x]--;
            dfs(i);
            break;
        }
    }
}

void fleury(int x)
{
     
    top = 1;
    ans[top] = x;
    while (top > 0)
    {
     
        int k = 0;
        for (int i = 1; i <= n; i++)//判断是否可扩展
        {
     
            if (map[ans[top]][i] >= 1)//若存在一条从ans[top]出发的边  那么就是可扩展
            {
     
                k = 1; break;
            }
        }
        if (k == 0)//该点x没有其他的边可以先走了（即不可扩展）， 那么就输出它
        {
     
            printf("%d ", ans[top]);
            top--;
        }
        else if (k == 1)//如可扩展， 则dfs可扩展的哪条路线
        {
     
            top--;//这需要注意
            dfs(ans[top + 1]);
        }
    }
}
int main()
{
     
    while (scanf("%d%d", &n, &m) != EOF)
    {
     
        memset(du, 0, sizeof(du));
        memset(map, 0, sizeof(map));

        for (int i = 1; i <= m; i++)
        {
     
            int x, y;
            scanf("%d%d", &x, &y);
            map[x][y]++; //记录边， 因为是无向图所以加两条边， 两个点之间可能有多条边
            map[y][x]++;
            du[x]++;
            du[y]++;
        }
        flag = 1; // flag标记开始点。 如果所有点度数全为偶数那就从1开始搜
        sum = 0;
        for (int i = 1; i <= n; i++)
        {
     
            if (du[i] % 2 == 1)
            {
     
                sum++;
                flag = i;// 若有奇数边， 从奇数边开始搜
            }
        }
        if (sum == 0 || sum == 2)//度数均为偶数或仅有两个奇度定点则开始算法
            fleury(flag);
    }
    return 0;
}

prufer编码

prufer编码转树（更新于2021/1/6）

#include
#include
#include
#include
using namespace std;
#define MAX 20//顶点数最大值
typedef struct arc
{
     
	int u;
	int v;
}arcnode;
queue<int> q1;
int flag[MAX];
int n, m, edgenum;
int min();
int main()
{
     
	arcnode edge[MAX * (MAX - 1) / 2];//边集
	scanf_s("%d", &n);//顶点数
	for (int i = 0; i < n - 2; i++)
	{
     
		scanf_s("%d", &m);
		q1.push(m);
		flag[m]++;
	}
	q1.push(n);
	flag[n]++;
	while(!q1.empty())
	{
     
		int u = min();
		flag[u]++;
		int v = q1.front();
		q1.pop();
		flag[v]--;
		edge[edgenum].u = u;
		edge[edgenum].v = v;
		edgenum++;
	}
	for (int i = 0; i < edgenum; i++)
	{
     
		printf("(%d,%d)\n", edge[i].u, edge[i].v);
	}
	return 0;
}
int min()//求不在队列内的点编号最小值
{
     
	for (int i = 1; i <= n; i++)
	{
     
		if (flag[i] == 0)return i;
	}
}

LCA（更新于2021/1/6）

#include
#include
#define MAX 600000
using namespace std;
int n, m, s;//树节点个数，询问个数，根节点序号
int x, y;//查询点序号
int father[MAX][20], log_2[MAX], depth[MAX],lca[MAX];//father[i][j]表示节点i的第2^j级祖先
struct node
{
     
	int to;
	int next;
}edge[2*MAX];
int cnt, u, v, head[MAX];
void add_edge(int u, int v);
void dfs(int present_node, int father_node);
int LCA(int x, int y);//求点x和y的最近公共祖先
int main()
{
     
	memset(head, -1, sizeof(head));
	scanf_s("%d%d%d", &n, &m, &s);//树节点个数，询问个数，根节点序号
	for (int i = 0; i < n - 1; i++)
	{
     
		scanf_s("%d%d", &u, &v);
		add_edge(u, v); add_edge(v, u);
	}
	for (int i = 1; i <= n; ++i) //预先算出log_2(i)+1的值
		log_2[i] = log_2[i - 1] + (1 << log_2[i - 1] == i);
	dfs(s, 0);
	for (int i = 0; i < m; i++)
	{
     
		scanf_s("%d%d", &x, &y);
		lca[i] = LCA(x, y);	
	}
	for (int i = 0; i < m;i++)printf("%d\n", LCA(x, y));
	return 0;
}
void add_edge(int u, int v)
{
     
	edge[++cnt] = node{
      v,head[u] };
	head[u] = cnt;
}
void dfs(int present_node, int father_node)
{
     
	father[present_node][0] = father_node;
	depth[present_node] = depth[father_node] + 1;
	for (int i = 1; i <= log_2[depth[present_node]]; i++)
	{
     
		father[present_node][i] = father[father[present_node][i - 1]][i - 1];
	}//当前节点的2^i祖先等于当前节点的2^(i-1)级祖先的2^(i-1)级祖先即2^i=2^(i+1)+2^(i+1)
	for (int i = head[present_node]; i; i = edge[i].next)
	{
     
		if (edge[i].to != father_node)
			dfs(edge[i].to, present_node);
	}
}
int LCA(int x, int y)
{
     
	if (depth[x] < depth[y])
		swap(x, y);//不妨x的深度大于y的深度
	while (depth[x] > depth[y])
		x = father[x][log_2[depth[x] - depth[y]] - 1];//将x跳到与y同深度
	if (x == y)return x;
	for (int k = log_2[depth[x]] - 1; k >= 0; --k) //不断向上跳
	{
     
		if (father[x][k] != father[y][k])  //因为我们要跳到它们LCA的下面一层，所以它们肯定不相等，如果不相等就跳过去。
			x = father[x][k], y = father[y][k];
	}
	return father[x][0];  //返回父节点
}

tarjan求割点（更新于2021/1/6）

#include
#include
#include
#include
#define MAX 20100
using namespace std;
int n, m, index1, cutnum;
int LOW[MAX], cut_vex[MAX], DFN[MAX];
struct node
{
     
	int to;
	int next;
}edge[MAX * 10];
int u, v;
int head[MAX], cnt;
void add_edge(int u, int v);
void tarjan(int u, int fa);
int main()
{
     
	memset(DFN, 0, sizeof(DFN));
	memset(head, -1, sizeof(head));
	scanf("%d%d", &n, &m);
	for (int i = 0; i < m; i++)
	{
     
		scanf("%d%d", &u, &v);
		add_edge(u, v);
		add_edge(v, u);
	}
	for (int i = 1; i <= n; i++)
	{
     
		if (DFN[i] == 0)
			tarjan(i, i);
	}
	for (int i = 1; i <= n; i++)
	{
     
		if (cut_vex[i])
			cutnum++;
	}
	printf("%d\n", cutnum);
	for (int i = 1; i <= n; i++)
	{
     
		if (cut_vex[i])
			printf("%d ", i);
	}
}
void add_edge(int u, int v)
{
     
	edge[++cnt].to = v;
	edge[cnt].next = head[u];
	head[u] = cnt;
}
void tarjan(int u, int fa)//当前节点及其父节点
{
     
	index1++;
	DFN[u] = index1;
	LOW[u] = index1;//index记录遍历的点的个数，当前节点的DFN和LOW均为查询顺序
	int child = 0;
	for (int i = head[u]; i != -1; i = edge[i].next)//遍历当前节点的所有子节点
	{
     
		int nx = edge[i].to;
		if (!DFN[nx])//若该子节点未访问则求出其所在连通分量
		{
     
			tarjan(nx, fa);
			LOW[u] = min(LOW[u], LOW[nx]);//更新当前节点的最近根节点
			if (LOW[nx] >= DFN[u] && u != fa)//
				cut_vex[u] = 1;
			if (u == fa)
				child++;
		}
		LOW[u] = min(LOW[u], DFN[nx]);
	}
	if (child >= 2 && u == fa)
		cut_vex[u] = 1;
}

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
基于社交网络算法优化的二维最大熵图像分割智能算法研学社（Jack旭）智能优化算法应用图像分割算法 php 开发语言
智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
121. 买卖股票的最佳时机薄荷糖的味道_fb40
给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insert into select 主键自增 mybatis delete返回值 mybatis insert返回主键 mybatis insert返回对象 mybatis plus insert返回主键 mybatis plus 插入生成id
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
k均值聚类算法考试例题_k均值算法(k均值聚类算法计算题) 寻找你83497 k均值聚类算法考试例题
?算法：第一步：选K个初始聚类中心，z1(1),z2(1)，…，zK(1)，其中括号内的序号为寻找聚类中心的迭代运算的次序号。聚类中心的向量值可任意设定，例如可选开始的K个.k均值聚类：---------一种硬聚类算法，隶属度只有两个取值0或1，提出的基本根据是“类内误差平方和最小化”准则；模糊的c均值聚类算法：--------一种模糊聚类算法，是.K均值聚类算法是先随机选取K个对象作为初始的聚类
Python实现简单的机器学习算法 master_chenchengg python python 办公效率 python开发 IT
Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
推荐算法_隐语义-梯度下降 _feivirus_ 算法机器学习和数学推荐算法机器学习隐语义
importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习 K近邻
importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列 C语言
文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
[Python] 数据结构详解及代码 AIAdvocate 算法 python 数据结构链表
今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
Python算法L5：贪心算法小熊同学哦 Python算法算法 python 贪心算法
Python贪心算法简介目录Python贪心算法简介贪心算法的基本步骤贪心算法的适用场景经典贪心算法问题1.**零钱兑换问题**2.**区间调度问题**3.**背包问题**贪心算法的优缺点优点：缺点：结语贪心算法（GreedyAlgorithm）是一种在每一步选择中都采取当前最优或最优解的算法。它的核心思想是，在保证每一步局部最优的情况下，希望通过贪心选择达到全局最优解。虽然贪心算法并不总能得到全
【RabbitMQ 项目】服务端：数据管理模块之绑定管理月夜星辉雪 rabbitmq 分布式
文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
非对称加密算法原理与应用2——RSA私钥加密文件私语茶馆云部署与开发架构及产品灵感记录 RSA2048 私钥加密
作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
粒子群优化 (PSO) 在三维正弦波函数中的应用 subject625Ruben 机器学习人工智能 matlab 算法
在这篇博客中，我们将展示如何使用粒子群优化（PSO）算法求解三维正弦波函数，并通过增加正弦波扰动，使优化过程更加复杂和有趣。本文将介绍目标函数的定义、PSO参数设置以及算法执行的详细过程，并展示搜索空间中的动态过程和收敛曲线。1.目标函数定义我们使用的目标函数是一个三维正弦波函数，定义如下：objectiveFunc=@(x)sin(sqrt(x(1).^2+x(2).^2))+0.5*sin(5
非对称加密算法————RSA理论及详情 hu19930613
转自：https://www.kancloud.cn/kancloud/rsa_algorithm/48484一、一点历史1976年以前，所有的加密方法都是同一种模式：（1）甲方选择某一种加密规则，对信息进行加密；（2）乙方使用同一种规则，对信息进行解密。由于加密和解密使用同样规则（简称"密钥"），这被称为"对称加密算法"（Symmetric-keyalgorithm）。这种加密模式有一个最大弱点
ai绘画工具midjourney怎么下载？附作品管理教程设计师早上好
Midjourney是一款功能强大的AI绘画工具，它使用机器学习技术和深度神经网络等算法，可以生成各种艺术风格的绘画作品。在创意设计、广告宣传等方面有着广泛的应用前景。那么，ai绘画工具midjourney怎么下载？本文将为您介绍Midjourney的下载以及作品的相关管理。一、Midjourney下载Midjourney的下载非常简单，只需打开Midjourney官网（点击“GetMidjour
【加密算法基础——对称加密和非对称加密】 XWWW668899 网络安全服务器笔记
对称加密与非对称加密对称加密和非对称加密是两种基本的加密方法，各自有不同的特点和用途。以下是详细比较：1.对称加密特点密钥:使用相同的密钥进行加密和解密。发送方和接收方必须共享这个密钥。速度:通常速度较快，适合处理大量数据。实现:算法相对简单，计算效率高。常见算法AES(高级加密标准)DES(数据加密标准)3DES(三重数据加密标准)RC4(流密码)应用场景文件加密磁盘加密传输大量数据时的加密2.
【算法练习】IDEA集成leetcode插件实现快速刷 2401_84102892 2024年程序员学习算法 intellij-idea leetcode
============点击右侧边leetcode->设置->配置地址、用户名、密码、存放目录、文件模板用户名要登录后在账号信息里看模板代码1.codefilename!velocityTool.camelC
【加密算法基础——RSA 加密】 XWWW668899 网络服务器笔记 python
RSA加密RSA（Rivest-Shamir-Adleman）加密是非对称加密，一种广泛使用的公钥加密算法，主要用于安全数据传输。公钥用于加密，私钥用于解密。RSA加密算法的名称来源于其三位发明者的姓氏：R:RonRivestS:AdiShamirA:LeonardAdleman这三位计算机科学家在1977年共同提出了这一算法，并发表了相关论文。他们的工作为公钥加密的基础奠定了重要基础，使得安全通
机器学习-聚类算法不良人龍木木机器学习机器学习算法聚类
机器学习-聚类算法1.AHC2.K-means3.SC4.MCL仅个人笔记，感谢点赞关注！1.AHC2.K-means3.SC传统谱聚类：个人对谱聚类算法的理解以及改进4.MCL目前仅专注于NLP的技术学习和分享感谢大家的关注与支持！
生成式地图制图 Bwywb_3 深度学习机器学习深度学习生成对抗网络
生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
高性能javascript--算法和流程控制海淀萌狗
-for,while和do-while性能相当-避免使用for-in循环，==除非遍历一个属性量未知的对象==es5:for-in遍历的对象便不局限于数组，还可以遍历对象。原因：for-in每次迭代操作会同时搜索实例或者原型属性，for-in循环的每次迭代都会产生更多开销，因此要比其他循环类型慢，一般速度为其他类型循环的1/7。因此，除非明确需要迭代一个属性数量未知的对象，否则应避免使用for-i
深度 Qlearning：在直播推荐系统中的应用 AGI通用人工智能之禅程序员提升自我硅基计算碳基计算认知计算生物计算深度学习神经网络大数据 AIGC AGI LLM Java Python 架构设计 Agent 程序员实现财富自由
深度Q-learning：在直播推荐系统中的应用关键词：深度Q-learning,强化学习,直播推荐系统,个性化推荐1.背景介绍1.1问题的由来随着互联网技术的飞速发展,直播平台如雨后春笋般涌现。面对海量的直播内容,用户很难快速找到自己感兴趣的内容。因此,个性化推荐系统在直播平台中扮演着越来越重要的角色。1.2研究现状目前,主流的个性化推荐算法包括协同过滤、基于内容的推荐等。这些方法在一定程度上缓
JVM源码分析之堆外内存完全解读 HeapDump性能社区
概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
《算法》四学习——1.1节进阶的Farmer 算法算法笔记
前言买了一本算法4，每天看一点，对每个小结来个学习总结，输出驱动输入。本篇笔记针对第一章基础1.1基础编程模型1.1节总结了相关的语法、语言特性和书中将会用到的库。笔记自己在编码中容易遗漏的点&&优先级比||高在开发中习惯了加括号，所以没注意到这点，教材上也有但是忘记了二分查找中计算mid=left+(right-left)/2这样计算可以有效避免(left+right)/2溢出答疑java无穷大
排序路小白同学
1.冒泡排序冒泡算法是一种基础的排序算法，这种算法会重复的比较数组中相邻的两个元素。如果一个元素比另一个元素大（小），那么就交换这两个元素的位置。重复这一比较直至最后一个元素。这一比较会重复n-1趟，每一趟比较n-j次，j是已经排序好的元素个数。每一趟比较都能找出未排序元素中最大或者最小的那个数字。这就如同水泡从水底逐个飘到水面一样。冒泡排序是一种时间复杂度较高，效率较低的排序方法。其空间复杂度是
安装数据库首次应用 Array_06 java oracle sql
可是为什么再一次失败之后就变成直接跳过那个要求 enter full pathname of java.exe的界面这个java.exe是你的Oracle 11g安装目录中例如：【F:\app\chen\product\11.2.0\dbhome_1\jdk\jre\bin】下的java.exe 。不是你的电脑安装的java jdk下的java.exe！注意第一次，使用SQL D
Weblogic Server Console密码修改和遗忘解决方法 bijian1013 Welogic
在工作中一同事将Weblogic的console的密码忘记了，通过网上查询资料解决，实践整理了一下。一.修改Console密码打开weblogic控制台，安全领域 --> myrealm -->&n
IllegalStateException: Cannot forward a response that is already committed Cwind java Servlets
对于初学者来说，一个常见的误解是：当调用 forward() 或者 sendRedirect() 时控制流将会自动跳出原函数。标题所示错误通常是基于此误解而引起的。示例代码： protected void doPost() { if (someCondition) { sendRedirect(); } forward(); // Thi
基于流的装饰设计模式木zi_鸣设计模式
当想要对已有类的对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能，并提供加强功能。自定义的类成为装饰类模仿BufferedReader，对Reader进行包装，体现装饰设计模式装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰的对象功能，提供更强的功能。装饰模式比继承灵活，避免继承臃肿，降低了类与类之间的关系装饰类因为增强已有对象，具备的功能该
Linux中的uniq命令被触发 linux
Linux命令uniq的作用是过滤重复部分显示文件内容，这个命令读取输入文件，并比较相邻的行。在正常情况下，第二个及以后更多个重复行将被删去，行比较是根据所用字符集的排序序列进行的。该命令加工后的结果写到输出文件中。输入文件和输出文件必须不同。如果输入文件用“- ”表示，则从标准输入读取。 AD： uniq [选项] 文件说明：这个命令读取输入文件，并比较相邻的行。在正常情况下，第二个
正则表达式Pattern 肆无忌惮_ Pattern
正则表达式是符合一定规则的表达式，用来专门操作字符串，对字符创进行匹配，切割，替换，获取。例如，我们需要对QQ号码格式进行检验规则是长度6~12位不能0开头只能是数字，我们可以一位一位进行比较，利用parseLong进行判断，或者是用正则表达式来匹配[1-9][0-9]{4,14} 或者 [1-9]\d{4,14} &nbs
Oracle高级查询之OVER (PARTITION BY ..) 知了ing oracle sql
一、rank()/dense_rank() over(partition by ...order by ...) 现在客户有这样一个需求，查询每个部门工资最高的雇员的信息，相信有一定oracle应用知识的同学都能写出下面的SQL语句： select e.ename, e.job, e.sal, e.deptno from scott.emp e, (se
Python调试矮蛋蛋 python pdb
原文地址： http://blog.csdn.net/xuyuefei1988/article/details/19399137 1、下面网上收罗的资料初学者应该够用了，但对比IBM的Python 代码调试技巧： IBM：包括 pdb 模块、利用 PyDev 和 Eclipse 集成进行调试、PyCharm 以及 Debug 日志进行调试： http://www.ibm.com/d
webservice传递自定义对象时函数为空，以及boolean不对应的问题 alleni123 webservice
今天在客户端调用方法 NodeStatus status=iservice.getNodeStatus(). 结果NodeStatus的属性都是null。进行debug之后，发现服务器端返回的确实是有值的对象。后来发现原来是因为在客户端，NodeStatus的setter全部被我删除了。本来是因为逻辑上不需要在客户端使用setter，结果改了之后竟然不能获取带属性值的
java如何干掉指针，又如何巧妙的通过引用来操作指针————>说的就是java指针百合不是茶
C语言的强大在于可以直接操作指针的地址，通过改变指针的地址指向来达到更改地址的目的,又是由于c语言的指针过于强大，初学者很难掌握， java的出现解决了c，c++中指针的问题 java将指针封装在底层，开发人员是不能够去操作指针的地址，但是可以通过引用来间接的操作：定义一个指针p来指向a的地址（&是地址符号）：
Eclipse打不开，提示“An error has occurred.See the log file ***/.log” bijian1013 eclipse
打开eclipse工作目录的\.metadata\.log文件，发现如下错误： !ENTRY org.eclipse.osgi 4 0 2012-09-10 09:28:57.139 !MESSAGE Application error !STACK 1 java.lang.NoClassDefFoundError: org/eclipse/core/resources/IContai
spring aop实例annotation方法实现 bijian1013 java spring AOP annotation
在spring aop实例中我们通过配置xml文件来实现AOP，这里学习使用annotation来实现，使用annotation其实就是指明具体的aspect,pointcut和advice。1.申明一个切面(用一个类来实现)在这个切面里,包括了advice和pointcut AdviceMethods.jav
[Velocity一]Velocity语法基础入门 bit1129 velocity
用户和开发人员参考文档 http://velocity.apache.org/engine/releases/velocity-1.7/developer-guide.html 注释 1.行级注释## 2.多行注释#* *# 变量定义使用$开头的字符串是变量定义，例如$var1, $var2, 赋值使用#set为变量赋值，例
【Kafka十一】关于Kafka的副本管理 bit1129 kafka
1. 关于request.required.acks request.required.acks控制者Producer写请求的什么时候可以确认写成功，默认是0， 0表示即不进行确认即返回。 1表示Leader写成功即返回，此时还没有进行写数据同步到其它Follower Partition中 -1表示根据指定的最少Partition确认后才返回，这个在 Th
lua统计nginx内部变量数据 ronin47 lua nginx　统计
server { listen 80; server_name photo.domain.com; location /{set $str $uri; content_by_lua ' local url = ngx.var.uri local res = ngx.location.capture(
java-11.二叉树中节点的最大距离 bylijinnan java
import java.util.ArrayList; import java.util.List; public class MaxLenInBinTree { /* a. 1 / \ 2 3 / \ / \ 4 5 6 7 max=4 pass "root"
Netty源码学习-ReadTimeoutHandler bylijinnan java netty
ReadTimeoutHandler的实现思路：开启一个定时任务，如果在指定时间内没有接收到消息，则抛出ReadTimeoutException 这个异常的捕获，在开发中，交给跟在ReadTimeoutHandler后面的ChannelHandler，例如 private final ChannelHandler timeoutHandler = new ReadTim
jquery验证上传文件样式及大小(好用) cngolon 文件上传 jquery验证
<!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <script src="jquery1.8/jquery-1.8.0.
浏览器兼容【转】 cuishikuan css 浏览器 IE
浏览器兼容问题一：不同浏览器的标签默认的外补丁和内补丁不同问题症状：随便写几个标签，不加样式控制的情况下，各自的margin 和padding差异较大。碰到频率:100% 解决方案：CSS里 *{margin:0;padding:0;} 备注：这个是最常见的也是最易解决的一个浏览器兼容性问题，几乎所有的CSS文件开头都会用通配符*来设
Shell特殊变量：Shell $0, $#, $*, $@, $?, $$和命令行参数 daizj shell $#$?特殊变量
前面已经讲到，变量名只能包含数字、字母和下划线，因为某些包含其他字符的变量有特殊含义，这样的变量被称为特殊变量。例如，$ 表示当前Shell进程的ID，即pid，看下面的代码： $echo $$ 运行结果 29949 特殊变量列表变量含义 $0 当前脚本的文件名 $n 传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个
程序设计KISS 原则-------KEEP IT SIMPLE, STUPID! dcj3sjt126com unix
翻到一本书，讲到编程一般原则是kiss：Keep It Simple, Stupid.对这个原则深有体会，其实不仅编程如此，而且系统架构也是如此。 KEEP IT SIMPLE, STUPID! 编写只做一件事情，并且要做好的程序；编写可以在一起工作的程序，编写处理文本流的程序，因为这是通用的接口。这就是UNIX哲学.所有的哲学真正的浓缩为一个铁一样的定律，高明的工程师的神圣的“KISS 原
android Activity间List传值 dcj3sjt126com Activity
第一个Activity： import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import a
tomcat 设置java虚拟机内存 eksliang tomcat 内存设置
转载请出自出处：http://eksliang.iteye.com/blog/2117772 http://eksliang.iteye.com/ 常见的内存溢出有以下两种: java.lang.OutOfMemoryError: PermGen space java.lang.OutOfMemoryError: Java heap space ------------
Android 数据库事务处理 gqdy365 android
使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务。事
Java 打开浏览器 hw1287789687 打开网址 open浏览器 open browser 打开url 打开浏览器
使用java 语言如何打开浏览器呢? 我们先研究下在cmd窗口中,如何打开网址使用IE 打开 D:\software\bin>cmd /c start iexplore http://hw1287789687.iteye.com/blog/2153709 使用火狐打开 D:\software\bin>cmd /c start firefox http://hw1287789
ReplaceGoogleCDN：将 Google CDN 替换为国内的 Chrome 插件 justjavac chrome Google google api chrome插件
Chrome Web Store 安装地址： https://chrome.google.com/webstore/detail/replace-google-cdn/kpampjmfiopfpkkepbllemkibefkiice 由于众所周知的原因，只需替换一个域名就可以继续使用Google提供的前端公共库了。同样，通过script标记引用这些资源，让网站访问速度瞬间提速吧
进程VS.线程 m635674608 线程
资料来源： http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001397567993007df355a3394da48f0bf14960f0c78753f000 1、Apache最早就是采用多进程模式 2、IIS服务器默认采用多线程模式 3、多进程优缺点优点：多进程模式最大
Linux下安装MemCached 字符串 memcached
前提准备：1. MemCached目前最新版本为：1.4.22，可以从官网下载到。2. MemCached依赖libevent，因此在安装MemCached之前需要先安装libevent。2.1 运行下面命令，查看系统是否已安装libevent。[root@SecurityCheck ~]# rpm -qa|grep libevent libevent-headers-1.4.13-4.el6.n
java设计模式之--jdk动态代理（实现aop编程） Supanccy2013 java DAO 设计模式 AOP
与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 &
Spring 4.2新特性-对java8默认方法(default method)定义Bean的支持 wiselyman spring 4
2.1 默认方法(default method) java8引入了一个default medthod; 用来扩展已有的接口,在对已有接口的使用不产生任何影响的情况下,添加扩展使用default关键字 Spring 4.2支持加载在默认方法里声明的bean 2.2 将要被声明成bean的类 public class DemoService {

图论模板，不定期更新

图论模板，随缘不定期更新

网络流

最大流

dinic（更新于2021/1/6）

hlpp（更新于2021/1/6）

最小费用最大流（更新于2021/1/6）

无源汇有上下界可行流（更新于2021/1/6）

有源汇上下界最大流（更新于2021/1/6）

最短路径

dijkstra（更新于2021/1/6）

spfa（更新于2021/1/6）

最小生成树

kruskal（更新于2021/1/6）

prim（更新于2021/1/6）

欧拉通路与欧拉回路

并查集（更新于2021/1/6）

判断存在欧拉回路（更新于2021/1/6）

寻找欧拉路径（更新于2021/1/6）

prufer编码

prufer编码转树（更新于2021/1/6）

LCA（更新于2021/1/6）

tarjan求割点（更新于2021/1/6）

你可能感兴趣的:(图论,算法)