清北学堂noip2018集训D4

最新推荐文章于 2020-11-23 21:55:32 发布
置顶 最新推荐文章于 2020-11-23 21:55:32 发布
阅读量373 收藏 2
点赞数 1
文章标签： 清北学堂
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013244048/article/details/82935383
版权
P.S.

最小生成树，最短路问题，SPFA算法，强连通分量。

图的读入

  • n m
    m行，u，v
    例如：
    6 8
    1 2
    1 3
    2 4
    3 4
    3 5
    4 1
    4 6
    5 6
    在这里插入图片描述

  • 6 8
    1 1
    1 2
    1 5
    2 5
    2 3
    3 4
    4 5
    4 6
    在这里插入图片描述

  • 一些术语

    • 简单图：无重边，无自环。
    • 路径：一组首尾相连的边的集合
    • 度数（入度，出度）：连接一个点的边的数量。
    • 连通图：图中任意两点都有路径连接。
    • 连通分量（联通块）：极大的联通子图。
    • 完全图：任意两点有边相连。n个点的完全图有 n ( n − 1 ) / 2 n(n-1)/2 n(n−1)/2。
    • 有向无环图（DAG）

  • 图的存储

    • 用的方便？
      • 检查两点之间是否有边。
      • 遍历（枚举）一个点的所有出边。
    • 邻接矩阵
      • 检查两点之间是否有边。
        在这里插入图片描述
      • 注意空间
        • 256 MB
        • 256*1024*1024 B
        • bool 1B
        • int 4B
        • long long 8B
        • double 8B
      • 时间
        • 1s 1 0 7 10^7 107 O(n)
      • 代码如下
        #include<bits/stdc++.h>
using namespace std;
int n,m;
// n*n
int graph[105][105];
int main(){
	scanf("%d%d",&m,&n);
	int x,y;
	for(int i=0;i<n;i++){
		scanf("%d%d",&x,&y);
		x--;y--;
		graph[x][y]=1;
		graph[y][x]=1;
		//重边：graph[x][y]++;
		//graph[x][y]++;
		//权值：graph[x][y]=z;
		//graph[y][x]=z;
	}
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			cout<<graph[i][j]<<" ";
		}
		cout<<endl;
	}
	return 0;
}
    • 邻接表
      • 遍历（枚举）一个点的所有出边。
      • n个链表
      • 对于每个点，开一个链表，链表存储当前这个点的所有出边。
      • 1 .vector存图 STL 可变长数组
      • 2 . 数组链表
        • 代码如下：
          #include<bits/stdc++.h>
using namespace std;
int n,m;
vector<int> a[10005];

int graph[105][105];
int main(){
	scanf("%d%d",&m,&n);
	int x,y;
	for(int i=0;i<n;i++){
		scanf("%d%d",&x,&y);
		a[x].push_back(y);
		a[y].push_back(x);//无向图 
	}
	int w=3;
	for(int i=0;i<a[w].size();i++){
		cout<<a[w][i]<<" ";
	}
	return 0;
}
      • 链表存储
        • 代码如下：
          #include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
int n,m;

//  数组链表 邻接表

//  链表头       链表节点的下一个节点     这条边指向图中的点 
int head[10005],nxt[30005],               ver[30005];
int tot;// 记录链表节点用了多少个 


void add(int x,int y){
	// 在x的链表中 加一条指向y的边 
	++tot;
	// 当前链表节点就是编号为tot 
	ver[tot]=y;
	nxt[tot]=head[x];
	head[x]=tot;
}

int main(){
	scanf("%d%d",&n,&m);
	for(int i=0,x,y;i<m;i++){
		scanf("%d%d",&x,&y);
		add(x,y);
		add(y,x);//无向图 
	}
	
	// 遍历一个点的所有出边 
	int x=5;
	for(int i=head[x];i;i=nxt[i]){
		int y=ver[i];
		printf("%d ",y);
	}
	
	return 0;
}
        • 带权值：
          #include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
int n,m;

//  数组链表 邻接表

//  链表头       链表节点的下一个节点     这条边指向图中的点   边的权值 
int head[10005],nxt[30005],               ver[30005] ,         w[30005];
int tot;// 记录链表节点用了多少个 

void add(int x,int y,int z){
	// 在x的链表中 加一条指向y的边 权值为z 
	++tot;
	// 当前链表节点就是编号为tot 
	ver[tot]=y;
	w[tot]=z;
	
	nxt[tot]=head[x];
	head[x]=tot;
}

int main(){
	scanf("%d%d",&n,&m);
	for(int i=0,x,y;i<m;i++){
		scanf("%d%d%d",&x,&y,&z);
		add(x,y,z);
		add(y,x,z);//无向图 
	}
	
	// 遍历一个点的所有出边 
	int x=5;
	for(int i=head[x];i;i=nxt[i]){
		int y=ver[i];
		
		printf("%d %d ",y,w[i]);
	}
	
	return 0;
}
    • 遍历图
      • dfs
      • 代码：
        #include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
int n,m;

//  数组链表 邻接表

//  链表头       链表节点的下一个节点     这条边指向图中的点 
int head[10005],nxt[30005],               ver[30005];
int tot;// 记录链表节点用了多少个 


void add(int x,int y){
	// 在x的链表中 加一条指向y的边 
	++tot;
	// 当前链表节点就是编号为tot 
	ver[tot]=y;
	nxt[tot]=head[x];
	head[x]=tot;
}

bool vis[10005];
void dfs(int x){
	printf("%d ",x);
	vis[x]=1;
	for(int i=head[x];i;i=nxt[i]){
		if(!vis[ver[i]]){
			dfs(ver[i]);
		}
	}
}

int main(){
	scanf("%d%d",&n,&m);
	for(int i=0,x,y;i<m;i++){
		scanf("%d%d",&x,&y);
		add(x,y);
		add(y,x);//无向图 
	}
	dfs(1);
	
	return 0;
}
      • bfs
      • 代码：
        #include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
int n,m;

//  数组链表 邻接表

//  链表头       链表节点的下一个链表节点     这条边指向图中的点 
int head[10005],nxt[30005],               ver[30005];
int tot;// 记录链表节点用了多少个 


void add(int x,int y){
	// 在x的链表中 加一条指向y的边 
	++tot;
	// 当前链表节点就是编号为tot 
	ver[tot]=y;
	nxt[tot]=head[x];
	head[x]=tot;
}

bool vis[10005]; // 是否已经入队 
int d[10005]; // 到起点的距离 
queue<int> q; // 队列  
// q.front() 队列的第一个元素  
// q.push(x) 把x加入到队列中  
// q.pop()弹出第一个数字  
// q.empty()返回队列是否为空 
// q.size()队列里还有多少元素 

int main(){
	scanf("%d%d",&n,&m);
	for(int i=0,x,y;i<m;i++){
		scanf("%d%d",&x,&y);
		add(x,y);
		add(y,x);//无向图 
	}
	
	// 遍历一个点的所有出边 
//	int x=5;
//	for(int i=head[x];i;i=nxt[i]){
//		int y=ver[i];
//		printf("%d ",y);
//	}

//	// 重复入队 
//	while(!q.empty()) {
//		int x=q.front();q.pop();
//		vis[x] = 1; 
//		// do something
//		
//		for(int i=head[x];i;i=nxt[i]){
//			if(!vis[ver[i]]){
//				q.push(ver[i]);
//			}
//		}
//	}

	q.push(1);vis[1]=1; /// !!!!
	while(!q.empty()) {
		int x=q.front();q.pop();
		
		// do something
		
		for(int i=head[x];i;i=nxt[i]){
			int y=ver[i];
			if(!vis[y]){
				vis[y] = 1;
				d[y] = d[x] + 1 ;
				q.push(y);
			}
		}
	}
	for(int i=1;i<=n;i++){
		printf("%d ",d[i]);
	}
	
	return 0;
}
    • 最短路
      • 多源最短路
        • Floyd
        • 考虑用dp解决这个问题；
        • d p [ i ] [ j ] [ k ] = m i n ( d p [ i − 1 ] [ j ] [ i ] + d p [ i − 1 ] [ i ] [ k ] , d p [ i − 1 ] [ j ] [ k ] ) dp[i][j][k]=min(dp[i-1][j][i]+dp[i-1][i][k],dp[i-1][j][k]) dp[i][j][k]=min(dp[i−1][j][i]+dp[i−1][i][k],dp[i−1][j][k])
        • d p [ j ] [ k ] = m i n ( d p [ j ] [ i ] + d p [ i ] [ k ] , d p [ j ] [ k ] ) dp[j][k]=min(dp[j][i]+dp[i][k],dp[j][k]) dp[j][k]=min(dp[j][i]+dp[i][k],dp[j][k])
        • 代码：
          #include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,m;
// n*n
// 100000 200000
int graph[105][105]; // 边权>0 
int floyd[105][105];
int main(){
	scanf("%d%d",&n,&m);
	for(int i=0,x,y,z;i<m;i++){
		scanf("%d%d%d",&x,&y,&z);
		graph[x][y]=z;
	}
	
	
	memset(floyd,0x3F,sizeof(floyd));
	for(int i=1;i<=n;i++) floyd[i][i] = 0; // 初始值 
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(graph[i][j]) floyd[i][j]=graph[i][j];
		}
	}
	// floyd O(n^3) 
	for(int k=1;k<=n;k++){ // 循环顺序注意 
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				floyd[i][j]=min(floyd[i][j],floyd[i][k]+floyd[k][j]);
			}
		}
	}
	int xx,yy;
	scanf("%d%d",&xx,&yy);
	printf("%d",floyd[xx][yy]);
	
	return 0;
}
      • 单源最短路
        • 求一个点到每个点的最短路
          • Dijkstra 迪杰斯特拉算法
          • SFPA算法
        • Dijkstra 迪杰斯特拉算法
        1. 从所有点中选择未标记的 d i s [ i ] dis[i] dis[i]值最小的顶点 i i i，将 i i i标记；
        2. 松弛节点 i i i的相邻节点
        3. 若所有点都被标记，结束。否则回到1
        4. 代码：
          #include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
int n,m;

//  数组链表 邻接表

//  链表头       链表节点的下一个节点     这条边指向图中的点   边的权值 
int head[10005],nxt[30005],               ver[30005] ,         w[30005];
int tot;// 记录链表节点用了多少个 

void add(int x,int y,int z){
	// 在x的链表中 加一条指向y的边 权值为z 
	++tot;
	// 当前链表节点就是编号为tot 
	ver[tot]=y;
	w[tot]=z;
	
	nxt[tot]=head[x];
	head[x]=tot;
}

struct N{
	int x,w;
	// x节点，w 当前d[x]的值
	friend bool operator < (N a,N b){ // C++重载运算符 
		return a.w>b.w;
	}
	N(int a=0,int b=0){ // 构造函数 
		x=a,w=b;
	}
};

priority_queue<N> pq;
int d[10005];
bool vis[10005]
int main(){
	scanf("%d%d",&n,&m);
	for(int i=0,x,y;i<m;i++){
		scanf("%d%d%d",&x,&y,&z);
		add(x,y,z);
		add(y,x,z);//无向图 
	}
	
	int s=1;
	memset(d,0x3f,sizeof d); // 0x3f3f3f3f
	d[s]=0;
	pq.push(N(s,d[s]);
//	pq.push((N){s,d[s]});
	while(!pq.empty()){
		int x=pq.top().x;pq.pop();
		if(vis[x]) continue;
		else vis[x]=1;
		for(int i=head[x];i;i=nxt[i]){
			int y=ver[i];
			if(d[y]>d[x]+w[i]){
				d[y]=d[x]+w[i];
				pq.push(N(y,d[y]));
			}
		}
	}
//	d[]
//	d[x] == 0x3f3f3f3f 不连通 
	
	
	return 0;
}
        • 带计数的算法（多个最短路）
          #include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
int n,m;

//  数组链表 邻接表

//  链表头       链表节点的下一个节点     这条边指向图中的点   边的权值 
int head[10005],nxt[30005],               ver[30005] ,         w[30005];
int tot;// 记录链表节点用了多少个 

void add(int x,int y,int z){
	// 在x的链表中 加一条指向y的边 权值为z 
	++tot;
	// 当前链表节点就是编号为tot 
	ver[tot]=y;
	w[tot]=z;
	
	nxt[tot]=head[x];
	head[x]=tot;
}


struct N{
	int x,w;
	// x节点，w 当前d[x]的值
	friend bool operator < (N a,N b){ // C++重载运算符 
		return a.w>b.w;
	}
	N(int a=0,int b=0){ // 构造函数 
		x=a,w=b;
	}
};

priority_queue<N> pq;
int d[10005]; //    最短路的权值 
int cnt[10005]; // 最短路的条数 
bool vis[10005]
int main(){
	scanf("%d%d",&n,&m);
	for(int i=0,x,y;i<m;i++){
		scanf("%d%d%d",&x,&y,&z);
		add(x,y,z);
		add(y,x,z);//无向图 
	}
	
	int s=1;
	memset(d,0x3f,sizeof d); // 0x3f3f3f3f
	d[s]=0;
	cnt[s] = 1;
	pq.push(N(s,d[s]);
//	pq.push((N){s,d[s]});
	while(!pq.empty()){
		int x=pq.top().x;pq.pop();
		if(vis[x]) continue;
		else vis[x]=1;
		for(int i=head[x];i;i=nxt[i]){
			int y=ver[i];
			if(d[y]>d[x]+w[i]){
				d[y]=d[x]+w[i];
				cnt[y]=cnt[x];
				pq.push(N(y,d[y]));
			}else if(d[y] == d[x]+w[i]){
				cnt[y]+=cnt[x];
			}
		}
	}
	// d[]
//	d[x] == 0x3f3f3f3f 不连通 
	
	
	return 0;
}
          • POJ 2387
        • SPFA
          • 流程：
          1. 将源点S出队。
          2. 从队列里取出头的点v，用原点到v的当前最短距离来更新源点到与v相邻的点的最短距离（松弛操作）
          3. 将最短距离更新过且不在队列中的点入队。
          4. 回到第二步，直到队列为空为止。
          • 最坏情况 O ( n m ) O(nm) O(nm)，大多数 O ( m ) / O ( k m ) O(m)/O(km) O(m)/O(km)
          • 可以处理负权。
          • 在稀疏图效率较高。
          • 示例代码：
            #include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
int n,m;

//  数组链表 邻接表

//  链表头       链表节点的下一个节点     这条边指向图中的点   边的权值 
int head[10005],nxt[30005],               ver[30005] ,         w[30005];
int tot;// 记录链表节点用了多少个 

void add(int x,int y,int z){
	// 在x的链表中 加一条指向y的边 权值为z 
	++tot;
	// 当前链表节点就是编号为tot 
	ver[tot]=y;
	w[tot]=z;
	
	nxt[tot]=head[x];
	head[x]=tot;
}




queue<int> q;
int d[10005];
bool inq[10005];
int main(){
	scanf("%d%d",&n,&m);
	for(int i=0,x,y;i<m;i++){
		scanf("%d%d%d",&x,&y,&z);
		add(x,y,z);
		add(y,x,z);//无向图 
	}
	
	int s=1;
	memset(d,0x3f,sizeof d); // 0x3f3f3f3f
	d[s]=0;
	q.push(s);
	inq[s]=1;
	while(!q.empty()){
		int x=q.front();q.pop();
		inq[x]=0;
		for(int i=head[x];i;i=nxt[i]){
			int y=ver[i];
			if(d[y]>d[x]+w[i]){
				d[y]=d[x]+w[i];
				if(!inq[y]) inq[y]=1,q.push(y);
			}
		}
	}
	// d[]
//	d[x] == 0x3f3f3f3f 不连通 
	
	
	return 0;
}
    • 最小生成树
      • 生成树：选出一个图的 n − 1 n-1 n−1条边，使其构成一棵树。
      • 最小生成树（MST）：边权和最小的那个生成树。
        最小生成树
      • Prim
        • Prim算法是通过先获取一个点，然后不断加入点的一个过程。
        • 初始化： V ’ = x , E ’ = ∅ V^’=x,E^’=\varnothing V’=x,E’=∅，x是随便一个节点。
        • 重复下列操作，直到 V ’ = V V^’=V V’=V
        • 在E集合当中选择最小的边<u,v>使得 u ∈ V ’ 但 是 v ∉ V ’ u\in V^’但是v\notin V^’ u∈V’但是v∈/​V’;
        • V ’ V^’ V’加入节点v， E ’ E^’ E’加入<u,v>
        • ( V ’ , E ’ ) (V^’,E^’) (V’,E’)为最小生成树。
        • 类似Dijkstra.
        • 示例代码：
          #include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
int n,m;

//  数组链表 邻接表

//  链表头       链表节点的下一个节点     这条边指向图中的点   边的权值 
int head[10005],nxt[30005],               ver[30005] ,         w[30005];
int tot;// 记录链表节点用了多少个 

void add(int x,int y,int z){
	// 在x的链表中 加一条指向y的边 权值为z 
	++tot;
	// 当前链表节点就是编号为tot 
	ver[tot]=y;
	w[tot]=z;
	
	nxt[tot]=head[x];
	head[x]=tot;
}


struct N{
	int x,w;
	// x节点，w 当前d[x]的值
	friend bool operator < (N a,N b){ // C++重载运算符 
		return a.w>b.w;
	}
	N(int a=0,int b=0){ // 构造函数 
		x=a,w=b;
	}
};

priority_queue<N> pq;
bool vis[10005]
int main(){
	scanf("%d%d",&n,&m);
	for(int i=0,x,y;i<m;i++){
		scanf("%d%d%d",&x,&y,&z);
		add(x,y,z);
		add(y,x,z);//无向图 
	}
	
	int s=1;
	d[s]=0;
	pq.push(N(s,0);
	int sum = 0;
//	pq.push((N){s,d[s]});
	while(!pq.empty()){
		int x=pq.top().x;
		sum+=pq.top().w; 
		pq.pop();
		
		if(vis[x]) continue;
		else vis[x]=1;
		for(int i=head[x];i;i=nxt[i]){
			int y=ver[i];
			if(!vis[y]){
				pq.push(N(y,w[i]));
			}
		}
	}
	// sum 最小生成树的权值和 
	
	
	return 0;
}
      • Kruskal
      • 给所有边按照边权从小到大的顺序排序；
      • 从小到大依次考虑每条边(u,v)（最开始没有任何的边）:
      • 如果u 与v 已经连通了，那么加入(u,v) 后会出现环，不添加
      • 如果u 与v 没有连通，那么加入(u,v) 使其连通
      • 并查集维护连通性。
      • 代码如下：
        #include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
int n,m;

int fa[1000005]; // fa[x] x在并查集树上的父亲是谁 

int get(int x){ // 返回x在并查集树上的根
	if(fa[x] == x) return x; 
	return fa[x]=get(fa[x]); // 路径压缩 
}

void merge(int x,int y){
	// 合并x所在集合 和 y所在集合
	x=get(x);
	y=get(y);
	fa[x]=y;
}

struct Edge{
	int x,y,z;
}edge[1000005];
bool cmp(Edge&a,Edge&b){
	return a.z<b.z;
}

int main(){
	
	
	
	scanf("%d%d",&n,&m);
	
	// 并查集初始化
	for(int i=1;i<=n;i++) fa[i]=i; 
	
	
	for(int i=1;i<=m;i++){
		scanf("%d%d%d",&edge[i].x,&edge[i].y,&edge[i].z);
	}
	sort(edge+1,edge+m+1,cmp);
	int sum = 0;
	for(int i=1;i<=m;i++){
		int u=edge[i].x,v=edge[i].y;
		if(get(u)!=get(v)){
			merge(u,v);
			sum+=edge[i].z;
		}
	}
	printf("%d",sum);
	// 货车运输
	
	/*
	for(int i=1;i<=m;i++){ // 相同边权的边 
		int u=edge[i].x,v=edge[i].y;
		if(get(u)!=get(v)){
			// i  
			sum+=edge[i].z;
		}
	}
	for(int i=1;i<=m;i++){ // 相同边权的边 
		int u=edge[i].x,v=edge[i].y;
		if(get(u)!=get(v)){
			merge(u,v);
			// i之前是可以 加进MST， 现在不行 
			sum+=edge[i].z;
		}
	}
	*/
	
	
	
	
	return 0;
}
        • POJ 2421 constructing roads
        • POJ 1789 Truck History
        • POJ1679 判断最小生成树的唯一性

    • 拓扑排序

      • 有向无环图
        有向无环图
      • 拓扑序指的是可以把所有点写成一个序列，使得所有边都是从前面的点连向后面的点。
      • DAG 可以进行拓扑排序。
      • 维护一个入度为0 的顶点的集合，每次从该集合中任意取出一个顶点，将该顶点放入保存结果的List 中。紧接着循环遍历由该顶点引出的所有边，从图中移除这条边，同时获取该边的另外一个顶点，如果该顶点的入度在减去本条边之后为0，那么也将这个顶点放到入度为0 的集合中。然后继续从集合中取出一个顶点，重复操作。
      • 当集合为空之后，检查图中是否还存在任何边，如果存在的话，说明图中至少存在一条环路。不存在的话则返回结果List，此List 中的顺序就是对图进行拓扑排序的结果。
      • O ( n + m ) O(n + m) O(n+m)
      • 代码如下：
        #include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
int n,m;

//  数组链表 邻接表

//  链表头       链表节点的下一个节点     这条边指向图中的点 
int head[10005],nxt[30005],               ver[30005];
int tot;// 记录链表节点用了多少个 


void add(int x,int y){
	// 在x的链表中 加一条指向y的边 
	++tot;
	// 当前链表节点就是编号为tot 
	ver[tot]=y;
	nxt[tot]=head[x];
	head[x]=tot;
}
int indegree[10005];
int a[10005];
queue<int> q;
int main(){
	scanf("%d%d",&n,&m);
	for(int i=0,x,y;i<m;i++){
		scanf("%d%d",&x,&y);
		add(x,y);
		indegree[y]++;
	}
	for(int i=1;i<=n;i++){
		if(indegree[i] == 0) q.push(i);
	}
	int cnt=0;
	while(!q.empty()){
		int x=q.front();q.pop();
		a[++cnt] = x;
		for(int i=head[x];i;i=nxt[i]){
			indegree[ver[i]] -- ;
			if(indegree[ver[i]]==0){
				q.push(ver[i]);
			}
		}
	}
	for(int i=1;i<=n;i++){
		printf("%d ",a[i]);
	}
	
	
	return 0;
}
吴越洋
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
清北学堂2018年普及组训练营内部资料
07-20
关于图的一些定义 • 图: 由两个集合{V,E}所组成，记作G(V,E) • V是图中顶点(Vertex)的非空有限集合。 • E是图中边(Edge)的有限集合。 • 这里只考虑简单图：无自环、无重边（平行边） • 子图(subgraph)：边的子集，以及相关联的点。
清北学堂2018noip集训D1
吴越洋的博客
10-01 1134
清北学堂2018noip集训D1 枚举算法 例1 n个二元组(x1,y1),(x2,y2),...,(xn,yn)(x_1,y_1),(x_2,y_2),...,(x_n,y_n)(x1​,y1​),(x2​,y2​),...,(xn​,yn​)。计算有多少对(xi,yi),(xj,yj)(x_i,y_i),(x_j,y_j)(xi​,yi​),(xj​,yj​)满足xi+yi=xj+yjx_i+...
清北学堂noip2018集训D2
吴越洋的博客
10-02 1089
清北学堂noip2018集训D2 P.S. 今天讲数据结构，大概包括了二叉堆，二叉搜索树，线段树，树状数组，并查集，st表，RMQ（倍增什么的），LCA。 二叉堆 基本功能 O(log n)插入元素 O(1)查最大（最小）元素 O(log n)删除最大（最小）元素 O(log n)删除任意元素 基本结构 最为常用的堆结构就是完全二叉堆。 在逻辑形式上，结构必须等同于完全二叉树，同时，...
清北学堂noip2018集训D3
吴越洋的博客
10-03 512
高精度算法 大数的存储 高精度加法 高精度乘法 快速幂 进制转换 素数 大于一且因数只有1和它本身。 算数基本定理 任何一个大于1的自然数 N,如果N不为质数，那么N可以唯一分解成有限个质数的乘积N=P1a1×P2a2×P3a3×......×PnanN=P_1^{a_1}\times P_2^{a_2}\times P_3^{a_3}\times ......\times P_n^{a_...
清北学堂noip2019集训D6——动态规划
吴越洋的博客
01-30 409
状态压缩DP 最短哈密顿回路问题 给定一个完全图，带正边权w(u,v)w(u,v)w(u,v)。求出一个顶点的排列v1,v2,...,vnv_1,v_2,...,v_nv1​,v2​,...,vn​，使得w(v1,v2),w(v2,v3),...,w(vn−1,vn),w(vn,v1)w(v_1,v_2),w(v_2,v_3),...,w(v_{n-1},v_n),w(v_n,v_1)w(v1​...
NOIP2018普及组试题及测试数据
07-31
NOIP2018普及组 全套试题、样例数据及测试数据 原版！
NOIP2018复赛评测数据
02-03
NOIP2018已经过去，许多人的心中都留下了阴影。这是NOIP2018的官方测评数据，希望能帮助你。
NOIP2018模拟卷(2.0).pdf
09-30
NOIP2018模拟卷(2.0) NOIP2018模拟卷(2.0) NOIP2018模拟卷(2.0) NOIP2018模拟卷(2.0) NOIP2018模拟卷(2.0) NOIP2018模拟卷(2.0) NOIP2018模拟卷(2.0) NOIP2018模拟卷(2.0) NOIP2018模拟卷(2.0) NOIP2018模拟卷(2.0)
NOIP2018提高组试题及测试数据
07-31
NOIP2018提高组day1+day2 全套试题、样例数据及测试数据 原版！
NOIP2018普及组C++试题.pdf
08-07
NOIP2018普及组C++试题.pdf
2020清北学堂NOIP刷题营day1Bernd
ShineEternal的笔记小屋
11-23 253
http://csp.ac/contest/49/problem/314 description： solution： 不难发现，对于 (x,y)(x,y)(x,y) 这个点，其左上部分肯定都小于它，右下部分都大于它。 也就是说，这个点可能的取值界定在了一个区间内。 这样的话，差分优化前缀和就可以做了。 code： #include<cstdio> #include<map> using namespace std; int f[5005*5005]; int main() {
清北学堂noip2019集训D2——数据结构
吴越洋的博客
01-26 348
基本数据结构 栈 STL：stack 定义：stack a; 查询堆顶：a.top(); 压入栈顶:a.pop(); 查询a中的元素个数：a.size(); 清空只能慢慢pop。 例题1 给定一个栈，维护三个操作。 1：将一个数x压入栈中。 2：求栈中数的最大值。 3：弹出栈顶的数。 Q&lt;=1000。 Q&lt;=100000。 例题2 给定一个栈，维护四个操作。 1：将一个数x压...
清北学堂noip2019集训D5——动态规划
吴越洋的博客
01-29 440
动态规划 动态规划难点 意识到这个题用动态规划解决 高效设计状态 多做题 最长上升子序列问题 题目： （） 设计状态： f[i]f[i]f[i]表示以a[i]a[i]a[i]结尾的最长上升子序列长度。 最终答案max1≤i≤nmax_1\leq i \leq nmax1​≤i≤n 如何转移？ for(int i=1;i&lt;=n;i++){ f[i]=1; for(int j=1;j...
【游记】记清北学堂国庆刷题班
Ferric Ion
10-05 4107
本渣渣表示自己十分蒟蒻又想考好NOIP于是就参加了清北的国庆刷题班。Day 09月30号一大早逃了一天课坐动车。坐地铁。坐公交。一整天。华北电力大学。逃了一天课。
NOIP2018提高组金牌训练营——贪心算法专题
逆境出勇者
07-30 1408
地址在这http://www.51nod.com/live/liveDescription.html#!liveId=18 pdf   http://wwwwodddd.com/Greed.pdf 题目链接 https://www.51nod.com/contest/problemList.html#!contestId=54&amp;randomCode=882897 （这是免费的，我和他...
清北学堂培训2019.4.28
weixin_33895657的博客
04-28 414
Day 1（冯哲） 今天的内容很杂但却都是基础知识 主要分为下面几个点 枚举 枚举也称作穷举，指的是从问题所有可能的解的集合中一一枚举各元素。用题目中给定的检验条件判定哪些是无用的，哪些是有用的。能使命题成立的即为其解。 有几个非常非常简单的例题： 这个题目类似于洛谷P1046 陶陶摘苹果 下放代码（不行不行太水了）： #include<iostream> #i...
清北学堂&TYVJ NOIP金秋冲刺训练营杯大奖赛
OZY的博客
09-16 1106
居然AK了?
【浮*光】【2017清北学堂集训DAY1】
flora715的博客
07-12 538
订餐  dish.c/cpp/pas (1s/256M) 【题目描述】 这个周末，Joe一如既往的拿出了外卖的点餐单。 菜单上从上到下列着N个菜，每个菜Joe会列出一个美味值。 Joe这次希望从菜单上连续地点K个菜，并且美味值之和最大。 但在计算美味值之和时，Joe有自己的一套计算方法： 由于他会按照顺序享受这K个菜，并且越吃越后面的菜他就越享受， 所以对于他吃的第i个菜，设它的美味...
2018.6清北学堂day4上午
y_immortal的博客 QwQ(qdez_ymh)
06-09 434
QwQ论迟到的一天 现在给出了三个定理： 1.对换改变排列的奇偶性 2.在全部n阶(n≥2)(n≥2)(n\ge2)排列中，奇偶排列各占一半 证明：将每个奇排列中的111和222进行交换，就能得到一个彼此不同的偶排列（因为要么2和1的对应位置不同，要么其他位置的数字不同），从而可以得出num奇≥num偶num奇≥num偶num_奇 \ge num_偶 偶排列同理。 所以num奇=num...
noip2018普及组初赛试题解析
最新发布
09-11
noip2018普及组初赛试题解析： 今年的noip2018普及组初赛试题较往年较难，涵盖了编程基础知识的多个方面。试题中的第一道题目是关于数学运算的，在给定的5个数中找到最大的那个数并输出即可。这道题考察的是学生...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值