复试机试常用算法复习

最新推荐文章于 2022-03-15 21:32:04 发布
最新推荐文章于 2022-03-15 21:32:04 发布
阅读量714 收藏 3
点赞数
分类专栏： 最小生成树 最短路 最近公共祖先
本文为博主原创文章，未经博主允许也可以转载。
本文链接：https://blog.csdn.net/FrankAx/article/details/105314783
版权

kmp

子串
kmp模板，偷懒直接find()了 0.0

#include <bits/stdc++.h>
using namespace std;
int main() {
	int n ;
	string s , t ;
	cin >> n >> t ; 
	vector<int>v ;
	for( int k = 2 ; k <= 16 ; k++ ) {
		s = "" ;
		for( int i = 1 ; i <= n ; i++ ) {
			int tmp = i ;
			while( tmp ) {
				v.push_back( tmp % k ) ;
				tmp /= k ;
			}
			for( int i = v.size() - 1 ; i >= 0 ; i-- ) {
				if( v[i] >= 10 ) {
					s += (char)( v[i] - 10 + 'A' ) ;
				} else {
					s += (char)( v[i] + '0' ) ;
				}
			}
			v.clear() ;
		}
		int pos = s.find(t) ;
		if( pos >= 0 && pos < s.size() ) {
			cout << "yes" << endl ;
			return 0 ;
		}
	}
	cout << "no" << endl;
	return 0 ;
}

栗酱的数列
思路：kmp+差分
满足( a1 + b1 ) % k == ( a2 + b2 ) % k ， 与满足 ( a2 - a1 == b1 - b2 ) 一样
转换之后套kmp，找总共几个串满足

#include <bits/stdc++.h>
using namespace std;
#define LL long long 
const int AX = 2e5 + 666 ;
LL a[AX] ;
LL b[AX] ;
int nxt[AX] ;
int res , n , m ; 
void get_next(){
	nxt[0] = -1 ;
	int j = 0 , k = -1 ; 
	while( j < m ){
		if( k == -1 || b[k] == b[j] ){
			nxt[++j] = ++k ;
		}else{
			k = nxt[k] ; 
		}
	}
}

void kmp(){
	int i = 0 , j = 0 ;
	while( i < n && j < m ){
		if( j == -1 || a[i] == b[j] ){
			i ++ ;
			j ++ ;
		}else j = nxt[j] ; 
		if( j == m ){   // 
			res ++ ;
			j = nxt[j] ; 
		}
	}
}

int main(){
	int T ;
	LL	k ;
	cin >> T ;
	while( T-- ){
		res = 0 ;
		memset( nxt , 0 ,sizeof(nxt) ) ;
		cin >> n >> m >> k ;
		for( int i = 0 ; i < n ; i++ ){
			cin >> a[i] ;
		}
		for( int i = 0 ; i < m ; i++ ){
			cin >> b[i] ;
		}
		for( int i = 1 ; i < n ; i++ ){
			a[i-1] = ( ( a[i-1] - a[i] ) % k + k ) % k ;
		}
		for( int i = 1 ; i < m ; i++ ){
			b[i-1] = ( ( b[i] - b[i-1] ) % k + k ) % k ;
		}
		m --;
		n --;
		get_next();
		kmp();
		cout << res << endl ;
	}
	return 0 ;
}

manacher

回文串
Manacher 模板

#include <bits/stdc++.h>
using namespace std;
const int AX = 3e3 + 666 ;
char s[AX] ;
int p[AX] ;
int main(){
	while( ~scanf("%s",s) ){
		int len = strlen(s) ;
		for( int i = len ; i >= 0 ; i-- ){
			s[2*i+1] = '#' ;
			s[2*i+2] = s[i] ;
		}
		s[0] = '$' ;
		int id = 0 , mx = 0 ; 
		len *= 2 ; 
		memset( p , 0 , sizeof(p) );
		int res = 0 ;
		for( int i = 2 ; i <= len ; i++ ){
			if( p[id] + id > i ) p[i] = min( p[id] + id - i , p[2*id-i] );
			else p[i] = 1 ;
			while( s[i-p[i]] == s[i+p[i]] ) p[i]++ ;
			if( p[i] + i > mx ){
				mx = p[i] + i ; 
				id = i ;
			}
			res = max( res , p[i] );
		}
		printf("%d\n",res-1);
	}
	return 0 ;
}

最长回文
思路：要求两个串的子串拼起来为回文 的最大长度，首先分别对两个串求最长回文，枚举回文中心，然后向两边扩展，A的左边 == B的右边，就扩展。

#include <bits/stdc++.h>
using namespace std;
const int AX = 2e5 + 666 ;
char a[AX] , b[AX] ;
int pa[AX] , pb[AX] ;
int n ;
void manacher( char *s , int *p ){
	for( int i = n ; i >= 0 ; i-- ){
		s[2*i+2] = s[i] ;
		s[2*i+1] = '#' ;
	}
	s[0] = '$';
	int id = 0 , mx = 0 ; 
	for( int i = 2 ; i <= 2 * n ; i++ ){
		if( p[id] + id > i ) p[i] = min( p[id] + id - i , p[2*id-i] ) ;
		else p[i] = 1 ;
		while( s[i+p[i]] == s[i-p[i]] ) p[i] ++ ;
		if( i + p[i] > mx ){
			mx = p[i] + i ; 
			id = i ;
		}
	}
}
int main() {
	cin >> n ;
	cin >> a >> b ;
	manacher( a , pa ); 
	manacher( b , pb );
	int res = 0 ; 
	for( int i = 2 ; i <= 2 * n ; i++ ){
		int tmp = max( pa[i] , pb[i-2] );
		while( a[i-tmp] == b[i+tmp-2] ) tmp ++ ;
		res = max( res , tmp );
	}
	cout << res - 1 << endl;
	return 0 ;
}

Tarjan

可达性

/*
求出若干个强连通分量后，进行缩点：
    将每个强连通分量看做DAG图中的一个点，建立各点之间的边（本题直接统计各点(连通分量)入度）
    入度为0的强连通分量点集中取最小的点 构成所求集合
*/
#include <bits/stdc++.h>
using namespace std ;
const int AX = 1e5 + 666 ;
struct Node {
	int u , v , nxt ;
	Node() {}
	Node( int u , int v , int nxt ):u(u),v(v),nxt(nxt) {}
} G[AX];
vector<int>res ;
int head[AX] ;
int dfn[AX] ;
int low[AX] ;
int vis[AX] ;
int scc_id[AX] ;
int tot , cnt ;
int scc ; 
int in[AX] ;
vector<int>id[AX] ;  // 强连通分量集合
void add( int u , int v ) {
	G[tot] = Node( u , v , head[u] ) ;
	head[u] = tot ++ ;
}
stack<int>s;
void Tarjan( int u ) {
	dfn[u] = low[u] = ++cnt ;
	s.push(u);
	vis[u] = 1 ;
	for( int i = head[u] ; ~i ; i = G[i].nxt ) {
		int v = G[i].v ;
		if( !dfn[v] ) {
			Tarjan( v ) ;
			low[u] = min( low[u] , low[v] ) ;
		}else if( vis[v] ){
			low[u] = min( low[u] , low[v] ) ;
		}
	}
	if( dfn[u] == low[u] ) {
		int v = 0 ;
		while( u != v ){
			vis[s.top()] = 0 ;
			v = s.top() ; 
			scc_id[v] = scc ; 
			id[scc].push_back(v);
			s.pop() ; 
		}
		scc ++ ; 
	}
}
int main() {
	int n , m , x , y ;
	scanf("%d%d",&n,&m);
	cnt = tot = 0 ;
	scc = 0 ;
	memset( head , -1 , sizeof(head) ) ;
	memset( dfn , 0 , sizeof(dfn) ) ;
	memset( vis , 0 , sizeof(vis) ) ;
	memset( in , 0 , sizeof(in) ) ;
	for( int i = 0 ; i < m ; i++ ) {
		scanf("%d%d",&x,&y);
		add( x , y );
	}
	for( int i = 1 ; i <= n ; i++ ) {
		if( !dfn[i] ) {
			Tarjan( i ) ;
		}
	}
	
	for( int i = 1 ; i <= n ; i++ ){
		for( int j = head[i] ; ~j ; j = G[j].nxt ){
			if( scc_id[G[j].v] != scc_id[i] ){
				in[scc_id[G[j].v]]++ ; 		// 缩点
			}
		}
	}
	for( int i = 0 ; i < scc ; i++ ){
		sort( id[i].begin() , id[i].end() );
	}
	for( int i = 0 ; i < scc ; i++ ){
		if( !in[i] ) res.push_back(id[i][0]); // 入度0的最小点
	}
	sort( res.begin() , res.end() );
	int len = res.size() ;
	printf("%d\n",len);
	for( int i = 0 ; i < len ; i++ ) {
		printf("%d ",res[i]);
	}
	printf("\n");
	return 0 ;
}

Blockade
思路：去掉割点会造成若干个集合之间的点不能连接，去掉普通的点只会造成1个点与其余所有点不能连接。
故本题关键求割点对答案的贡献，有三部分：
一是和普通点一样，去掉的点与其余各点( n-1 ) * 2
二是去掉割点后，割点的 每个 子连通块与其余节点的数对
三是去掉割点后，割点所有上部的节点与其余节点的数对

#include <bits/stdc++.h>
#define LL long long 
using namespace std;
const int AX = 1e5 + 66 ;
int head[AX] ;
int dfn[AX] ;
int low[AX] ; 
LL res[AX] ; 
int num[AX] ;
int tot , cnt ;
int n , m ;
struct Node{
	int v , nxt ; 
	Node(){}
	Node( int v , int nxt ):v(v),nxt(nxt){}
}G[1000010] ;
void add( int u , int v ){
	G[tot] = Node( v , head[u] ) ;
	head[u] = tot ++ ;
	G[tot] = Node( u , head[v] ) ;
	head[v] = tot ++ ;
}

void Tarjan( int u , int pre ){
	dfn[u] = low[u] = ++cnt ;
	res[u] += 2LL * ( n - 1 ) ; // 1. 被去掉的点到其他各点
	num[u] = 1 ; 
	LL sum = 0 ;
	for( int i = head[u] ; ~i ; i = G[i].nxt ){
		int v = G[i].v ; 
		if( !dfn[v] ){
			Tarjan( v , u ) ;
			
			num[u] += num[v] ;	// u节点及子树节点数目
			
			low[u] = min( low[u] , low[v] ) ;
			
			if( low[v] >= dfn[u] ){ // u为割点
				res[u] += 1LL * num[v] * ( n - num[v] - 1 ) ;  // 2. 割点去除后的每个子连通块同其他连通块的数对
				
				sum += num[v] ; // 割点子树节点数目
			}
			
		}else if( v != pre ){
			low[u] = min( low[u] , dfn[v] );
		}
	}
	res[u] += 1LL * sum * ( n - sum - 1 ) ; // 3.sum为割点子树的所有点构成的连通块节点数目（tarjan在求割点的过程中是一棵搜索树往下遍历）
}

int main() {
	int u , v ;
	memset( head , -1 , sizeof(head) ) ;
	memset( res , 0 , sizeof(res) );
	memset( low , 0 , sizeof(low) );
	memset( dfn , 0 , sizeof(dfn) );
	memset( num , 0 , sizeof(num) );
	tot = cnt = 0 ; 
	scanf("%d%d",&n,&m);	
	for( int i = 0 ; i < m ; i++ ) {
		scanf("%d%d",&u,&v);
		add( u , v ) ;
	}
	Tarjan( 1 , 0 ) ;
	for( int i = 1 ; i <= n ; i++ ){
		printf("%lld\n",res[i]);
	}
	return 0 ;
}

最小生成树

1.道路建设
思路：模板

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
const int AX = 2e2 + 66 ;
int a[AX][AX];
int dis[AX] ;
int vis[AX] ;
int c , n , m , x , y , w ;
int prim() {
	int res = 0 ;
	memset( dis , 0x3f , sizeof(dis) ) ;
	memset( vis , 0 , sizeof(vis) ) ;
	dis[1] = 0 ;
	for( int i = 1 ; i <= n ; i++ ) {
		int minu = INF , id = 1 ;
		for( int j = 1 ; j <= n ; j++ ) {
			if( !vis[j] && minu > dis[j] ) {
				id = j ;
				minu = dis[j] ;
			}
		}
		if( minu == INF ) return -1 ;
		res += minu ;
		vis[id] = 1 ;
		for( int j = 1 ; j <= n ; j++ ) {
			if( !vis[j] && dis[j] > a[id][j] ) {
				dis[j] = a[id][j] ;
			}
		}
	}
	return res ;
}
int main() {
	while( ~scanf("%d%d%d",&c,&m,&n) ) {
		memset( a , 0x3f , sizeof(a) ) ;
		for( int i = 0 ; i < m ; i++ ) {
			scanf("%d%d%d",&x,&y,&w);
			a[x][y] = min( a[x][y] , w ) ;
			a[y][x] = a[x][y] ;
		}
		int res = prim();
		//cout << res << endl;
		if( res != -1 && res <= c ) printf("Yes\n");
		else printf("No\n");
	}
	return 0 ;
}

2.[HAOI2006]聪明的猴子
思路：找最小生成树的最大边。

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define eps 1e-10
using namespace std ;
const int AX = 1e3 + 66 ;
struct Node {
	double x , y ;
} G[AX] ;
int n , m ;
double get_dis( Node a , Node b ) {
	return sqrt( ( a.x - b.x ) * ( a.x - b.x ) + ( a.y - b.y ) * ( a.y - b.y ) ) ;
}
double a[AX] ;
double dis[AX] ;
int vis[AX] ;
double ans ;
void prim() {
	for( int i = 0 ; i < n ; i++ ){
		dis[i] = INF ;
	}
	memset( vis , 0 , sizeof(vis) ) ;
	dis[0] = 0 ;
	for( int i = 1 ; i <= n ; i++ ) {
		double minu = INF ;
		int id = 0 ;
		for( int j = 0 ; j < n ; j++ ) {
			if( !vis[j] && minu > dis[j] ) {
				minu = dis[j] ;
				id = j ;
			}
		}
		if( minu == INF ) return ;
		
		if( minu > ans ) {
			ans = minu ; 
		}
		
		vis[id] = 1 ;
		for( int j = 0 ; j < n ; j++ ) {
			double tmp = get_dis( G[id] , G[j] ) ;
			if( !vis[j] && dis[j] > tmp ) {
				dis[j] = tmp ;
			}
		}
	}
}
int main() {
	scanf("%d",&m);
	for( int i = 0 ; i < m ; i++ ) {
		scanf("%lf",&a[i]) ;
	}
	scanf("%d",&n);
	for( int i = 0 ; i < n ; i++ ) {
		scanf("%lf%lf",&G[i].x,&G[i].y);
	}
	ans = 0 ;
	prim();
	int res = 0 ; 

	for( int i = 0 ; i < m ; i++ ){
		if( a[i] >= ans ) res ++ ; 
	}
	printf("%d\n",res);
	return 0 ;
}

货车运输
思路：最大生成树+LCA
先求出最大生成树，再通过Tarjan算法，利用minu[x]记录点x到其 目前集合根节点 路径中 边的最小值
每次访问完以u为根的树后，处理查询(x,y),且处理的查询满足 x , y 的LCA都为u
其路径中最短边长度是 合并集合后 的 min(minu[x],minu[y])

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
typedef pair<int,int>P;
const int AX = 5e4 + 66 ;
int n , m ;
int tot ;
struct Edge {
	int u , v , w ;
	Edge( int u , int v , int w ):u(u),v(v),w(w) {}
	bool operator < ( const Edge &a )const {
		return w > a.w ;
	}
};
struct Node {
	int u , v , w , nxt ;
	Node() {}
	Node( int u , int v , int w , int nxt ):u(u),v(v),w(w),nxt(nxt) {}
} G[AX] ;

struct RES{
	int x , y , id ;
	RES( int x , int y , int id ):x(x),y(y),id(id){}
};
vector<RES>t_u[AX] ;
vector<Edge>e;
vector<P>que[AX] ;
int res[AX] ; 
int head[AX] ; 
int vis[AX] ;
int pre[AX] ;
int minu[AX] ;
void add( int u , int v , int w ){
	G[tot] = Node( u , v , w , head[u] ) ; head[u] = tot ++ ;
	G[tot] = Node( v , u , w , head[v] ) ; head[v] = tot ++ ;
}

int find( int x ){
	//return x == pre[x] ? x : pre[x] = find(pre[x]) ; 
	int tmp = pre[x] ; 
	if( x != tmp ){
		pre[x] = find(pre[x]);
	} 
	minu[x] = min( minu[x] , minu[tmp] );
	return pre[x] ; 
}
void mix( int x , int y ){
	x = find(x) ;
	y = find(y) ;
	if( x != y ){
		pre[x] = y ;
	}
}
void Tarjan( int u ){
	vis[u] = 1 ; 
	for( int i = head[u] ; ~i ; i = G[i].nxt ){
		int v = G[i].v ;
		if( vis[v] ) continue ; 
		Tarjan(v) ;
		minu[v] = G[i].w ; 
		pre[v] = u ;
	}
	for( int i = 0 ; i < (int)que[u].size() ; i++ ){ // 访问完以u为根的所有子树后，处理与u有关的询问 
		int v = que[u][i].first ; 
		int id = que[u][i].second ; 
		if( !vis[v] ) continue ;
		t_u[find(v)].push_back(RES(u,v,id));		// 与u相关的查询(u,v)，加入到find(v)集合去处理
 	}
	for( int i = 0 ; i < t_u[u].size() ; i++ ){ // 处理所有LCA为u的查询(x,y)，其路径中最短边长度是合并集合后的min(minu[x],minu[y])
		int id = t_u[u][i].id ; 
		int x = t_u[u][i].x ;
		int y = t_u[u][i].y ;
		find(x) ; find(y) ;
		res[id] = min( minu[x] , minu[y] );
	}
}
int main() {
	int x , y , w , q ;
	tot = 0 ;
	scanf("%d%d",&n,&m);
	for( int i = 1 ; i <= n ; i++ ){
		pre[i] = i ;
	}
	memset( head , -1 , sizeof(head) );
	memset( res , -1 , sizeof(res) ) ;
	memset( vis , 0 , sizeof(vis) ) ;
	while( m-- ) {
		scanf("%d%d%d",&x,&y,&w);
		e.push_back(Edge(x,y,w));
		e.push_back(Edge(y,x,w));
	}
	scanf("%d",&q);
	for( int i = 0 ; i < q ; i++ ) {
		scanf("%d%d",&x,&y);
		que[x].push_back(P(y,i));
		que[y].push_back(P(x,i));
	}
	sort( e.begin() , e.end() ) ;
	for( int i = 0 ; i < (int)e.size() ; i++ ){
		int u = e[i].u ;
		int v = e[i].v ; 
		if( find(u) != find(v) ){
			mix( u ,v ) ; 
			add( u , v , e[i].w );
		}
	}
	for( int i = 1 ; i <= n ; i++ ){
		pre[i] = i ;
	}
	memset( minu , 0x3f , sizeof(minu) );
	Tarjan(1);
	for( int i = 0 ; i < q ; i++ ){
		printf("%d\n",res[i]);
	}
	return 0 ;
}

【注】：这个题目求任意两点路径中的最小值，最大值同理。
另外，这个思路可以作为求次小生成树的更优解法。常规做法见次小生成树 ， 利用这题的思路时间上可以更优: 枚举不在最小生成树中的边<x,y>，查询生成树中x到y路径中的最大边长度，去除此最大长度，加上边<x,y>，取最小值

最短路

Travel
思路：点u到点v有两种方式：
一是不经过传送，只在环上逆时针或者顺时针走
二是会用到传送门（经过传送点x最短路径就是u到x最短路+x到v最短路）
两种情况取最小值就是答案

#include <bits/stdc++.h>
#define LL long long
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;
typedef pair<LL,int>P;
const int AX = 6e4 + 666 ;
int tot ;
int head[AX] ;
LL dis[50][AX] ;
LL pre[AX];
struct Node {
	int u , v , nxt ;
	LL w ;
	Node() {}
	Node( int u , int v , LL w , int nxt ):u(u),v(v),w(w),nxt(nxt) {}
} G[AX<<1];
int vis[AX] ;

void add( int u , int v , LL w ) {
	G[tot] = Node( u , v , w , head[u] ) ;
	head[u] = tot++ ;
	G[tot] = Node( v , u , w , head[v] ) ;
	head[v] = tot++ ;
}
void dijstra( int id ) {
	memset( vis , 0 ,sizeof(vis) ) ;
	int s = t[id] ;
	dis[id][s] = 0 ;
	priority_queue<P,vector<P>, greater<P> >q ;
	q.push(P(0,s)) ;
	while( !q.empty() ) {
		P tmp = q.top() ;
		q.pop() ;
		int u = tmp.second ;
		if( vis[u] ) continue ;
		vis[u] = 1 ;
		for( int i = head[u] ; ~i ; i = G[i].nxt ) {
			int v = G[i].v ;
			if( !vis[v] && dis[id][v] > dis[id][u] + G[i].w ) {
				dis[id][v] = dis[id][u] + G[i].w ;
				q.push(P(dis[id][v],v));
			}
		}
	}
}
int main() {
	int n , m , x , y ,q ;
	LL w ;
	scanf("%d%d",&n,&m);
	tot = 0 ;
	memset( head , -1 , sizeof(head) ) ;
	memset( dis , 0x3f , sizeof(dis) ) ;
	pre[0] = 0 ;
	for( int i = 1 ; i <= n ; i++ ) {
		scanf("%d",&x) ;
		add( i , ( i % n ) + 1 , x ) ;
		pre[i] = pre[i-1] + x ;
	}
	map<int,int>mp;
	while( m-- ) {
		scanf("%d%d%lld",&x,&y,&w) ;
		if( x == y ) continue ;
		add( x , y , w ) ;
		if( !mp[x] ) t.push_back(x);
		if( !mp[y] ) t.push_back(y);
		mp[x] = 1 ;
		mp[y] = 1 ;
	}
	int len = t.size() ;
	for( int i = 0 ; i < len ; i++ ) {  // 求出带传送的点到其余各点距离
		dijstra( i ) ;
	}
	scanf("%d",&q);
	while( q-- ) {
		scanf("%d%d",&x,&y);
		LL res = min( abs(pre[y-1] - pre[x-1]), pre[n] - abs(pre[y-1] - pre[x-1]) ) ; // 不经过传送，顺逆时针
		for( int i = 0 ; i < len ; i++ ) {
			res = min( res , dis[i][x] + dis[i][y] ) ;  // 经过传送
		}
		printf("%lld\n",res);
	}
	return 0 ;
}

最短路
思路：有负权无负环，用SPFA

#include <bits/stdc++.h>
using namespace std;
const int AX = 2e4 + 666 ;
int n , m ;
struct Node{
	int to , w ; 
	Node( int to , int w ):to(to),w(w){}
};
vector<Node>G[AX] ;
int vis[AX] ; 
int dis[AX] ; 
void spfa(){
	queue<int>q;
	q.push(1);
	vis[1] = 1 ;
	memset( dis , 0x3f , sizeof(dis) ) ;
	dis[1] = 0 ; 
	while( !q.empty() ){
		int u = q.front() ;
		q.pop() ; 
		vis[u] = 0 ; 
		for( int i = 0 ; i < G[u].size() ; i++ ){
			int v = G[u][i].to ; 
			if( dis[v] > dis[u] + G[u][i].w ){
				dis[v] = dis[u] + G[u][i].w ;
				if( !vis[v] ){
					vis[v] = 1 ;
					q.push(v);
				}
			}
		}
	}
}
int main(){
	scanf("%d%d",&n,&m);
	int x , y , w ; 
	while( m-- ){
		scanf("%d%d%d",&x,&y,&w);
		G[x].push_back(Node(y,w));
	}
	memset( vis , 0 , sizeof(vis) ) ;
	spfa();
	for( int i = 2 ; i <= n ; i++ ){
		printf("%d\n",dis[i]);
	}
	return 0 ; 
}

旅行
思路：枚举中间点，求到各点距离，取两段长度和的最大值。

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
typedef pair<int,int>P;
const int AX = 1e3 + 66;
struct Node {
	int v , w , nxt ;
	Node() {}
	Node( int v , int w , int nxt ):v(v),w(w),nxt(nxt) {}
} G[AX<<1] ;
int head[AX] ;
int vis[AX] ;
int tot ;
int dis[AX] ;
vector<int>ans ;
void add( int u , int v , int w ) {
	G[tot] = Node( v , w , head[u] ) ;
	head[u] = tot ++ ;
	G[tot] = Node( u , w , head[v] ) ;
	head[v] = tot ++ ;
}
bool cmp( int a , int b ) {
	return a > b ;
}
int n , m , x , y , w ;
int dijstra( int s ) {
	priority_queue< P , vector<P> , greater<P> >q ;
	q.push(P(0,s)) ;
	memset( vis , 0 , sizeof(vis) ) ;
	memset( dis , 0x3f , sizeof(dis) ) ;
	ans.clear() ;
	dis[s] = 0 ;
	while( !q.empty() ) {
		P tmp = q.top() ;
		q.pop() ;
		int u = tmp.second ;
		vis[u] = 1 ;
		for( int i = head[u] ; ~i ; i = G[i].nxt ) {
			int v = G[i].v ;
			if( !vis[v] && dis[v] > dis[u] + G[i].w ) {
				dis[v] = dis[u] + G[i].w ;
				q.push(P(dis[v],v));
			}
		}
	}
	for( int j = 1 ; j <= n ; j++ ) {
		if( j != s && dis[j] < INF )
			ans.push_back( dis[j] ) ;
	}
	if( ans.size() < 2 ) return -1 ;
	sort( ans.begin() , ans.end() , cmp ) ;
	return ans[0] + ans[1] ;
}
int main() {
	int T ;
	scanf("%d",&T);
	while( T-- ) {
		tot = 0 ;
		int res = -1 ;
		memset( head , -1 , sizeof(head) ) ;
		memset( dis , 0x3f , sizeof(dis) ) ;
		scanf("%d%d",&n,&m);
		while( m-- ) {
			scanf("%d%d%d",&x,&y,&w);
			add( x , y , w ) ;
		}
		for( int i = 1 ; i <= n ; i++ ) {
			res = max( res , dijstra( i ) ) ;
		}
		printf("%d\n",res);
	}
	return 0 ;
}

最短路
思路：i到j路径长度是 i ^ j ，这样边很多，可以将每条路径分解成2的幂次长度相加，故每个点相连路径只添加2的幂次长度，只有nlogn条边。

#include <bits/stdc++.h>
using namespace std;
int n , m , c , s , t ;
const int AX = 2e5 + 66 ;
struct Node{
	int v , w ;
	Node( int v , int w ):v(v),w(w){}
	bool operator < ( const Node &a )const{
		return w > a.w ; 
	}
};
vector<Node>G[AX] ;
int dis[AX] ; 
int vis[AX] ; 
void dijstra(){
	priority_queue<Node>q ;
	q.push(Node(s,0));
	memset( dis , 0x3f , sizeof(dis) ) ;
	dis[s] = 0 ;
	while( !q.empty() ){
		Node tmp = q.top() ; 
		q.pop();
		vis[tmp.v] = 1 ; 
		for( int i = 0 ; i < G[tmp.v].size() ; i++ ){
			int to = G[tmp.v][i].v ; 
			if( !vis[to] && dis[to] > dis[tmp.v] + G[tmp.v][i].w ){
				dis[to] = dis[tmp.v] + G[tmp.v][i].w ;
				q.push(Node(to,dis[to]));
			}
		}
	}
}
int main() {
	scanf("%d%d%d",&n,&m,&c);
	int x , y , w ; 
	for( int i = 0 ; i < m ; i++ ) {
		scanf("%d%d%d",&x,&y,&w) ;
		G[x].push_back(Node(y,w));
	} 
	scanf("%d%d",&s,&t);
	int tot = 1 ; 
	while( tot <= n ) tot <<= 1 ; 
	for( int i = 1 ; i < tot ; i++ ){
		for( int p = 1 ; p < tot ; p <<= 1 ){
			G[i].push_back(Node(i^p,p*c));
		}
	}
	dijstra();
	printf("%d\n",dis[t]);
	return 0 ;
}


强连通分量：

这题跟求强连通似乎并无关系0.0
不过简单题练练手
B题

思路：因为是个环，解一定是从1顺时针，或者逆时针。

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
const int AX = 1e2 + 66 ; 
int n ;
int a[AX][AX];
int res ; 
void dfs( int x , int pre , int num , int sum ){
	if( num == n + 1 ){
		res = min( res , sum );
		return ; 
	}
	for( int i = 1 ; i <= n ; i++ ){
		if( a[x][i] >= 0 && i != pre ){
			dfs( i , x , num + 1 , sum + a[x][i] );
		}
	}
}
int main() {
	int x , y , w ; 
	while( ~scanf("%d",&n) ){
		memset( a , -1 , sizeof(a) ) ;
		res = INF ; 
		for( int i = 0 ; i < n ; i++ ){
			scanf("%d%d%d",&x,&y,&w);
			a[y][x] = w ;
			a[x][y] = 0 ; 
		}
		dfs( 1 , -1 , 1 , 0 );
		printf("%d\n",res);
	}
	return 0 ;
}

二分图匹配

Graph Coloring I

思路：
染色法判断有无简单奇环
有简单奇环则染色不成功

输出环那部分比较难受

#include <bits/stdc++.h>
using namespace std;
const int AX = 3e5 + 66 ;
int n , m ;
vector<int>odd;
int col[AX] ;
vector<int>G[AX];
int pre[AX] ;
int f , s ;
void dfs( int x , int val ) {
	if( f ) return ;
	col[x] = val ;
	for( int i = 0 ; i < (int)G[x].size() ; i ++ ) {
		int y = G[x][i] ;
		if( col[y] == -1 ) {
			pre[y] = x ;
			dfs( y , val ^ 1 );
		} else if( col[x] == col[y] ) { // 有奇数环
			f = y ;   // 环终点
			s = x ;   // 环起点
			return ;
		}
	}
	return ;
}
int main() {
	int x , y ;
	scanf("%d%d",&n,&m);
	f = 0 ; // 无奇环
	memset( col , -1 , sizeof(col) ) ;
	for( int i = 0 ; i < m ; i++ ) {
		scanf("%d%d",&x,&y);
		G[x].push_back(y);
		G[y].push_back(x);
	}
	dfs( 1 , 0 ) ;
	if( !f ) {
		printf("0\n");
		for( int i = 1 ; i <= n ; i++ ) {
			printf("%d ",col[i]);
		}
		printf("\n");
	} else {
		int k = 0 ;
        for( int i = f ; i != s ; i = pre[i] ){
            k ++ ;
        }
        printf("%d\n", k + 1 );
        for( int i = f ; i != s ; i = pre[i] ){
            printf("%d ",i);
        }
        printf("%d\n",s);
	}
	return 0 ;
}

字典树

单词查找树
比板子题还要简单些的一道，以前复试题也没出过，就不写了

#include <bits/stdc++.h>
using namespace std ;
struct Trie{
	struct Trie *nxt[26] ;
	char c ; 
};
Trie* create(){
	Trie* rt = new Trie() ; 
	memset( rt -> nxt , 0 , sizeof(rt->nxt) ) ;
	return rt ; 
}
void insert(  Trie* rt , char *s ){
	int len = strlen(s) ;
	Trie* t = rt ; 
	while( *s ){
		int id = (*s)-'A' ; 
		if( t -> nxt[id] == NULL ){
			t -> nxt[id] = create();
		}
		t = t -> nxt[id] ;
		s ++ ; 
	}
} 
int res ;
void dfs( Trie* rt ){
	res ++ ;
	for( int i = 0 ; i < 26 ; i++ ){
		if( rt -> nxt[i] ){
			dfs( rt -> nxt[i] );
		}
	}
}
int main(){
	char s[66];
	res = 0 ;
	Trie* rt = create() ;
	while( ~scanf("%s",s) ){
		insert( rt , s ) ;
	}
	dfs( rt );
	printf("%d\n",res);
	return 0 ; 
}
Dave_L
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
考研复试机试参考资料和算法
05-01
考研复试机试参考资料和算法！！！！！！！！！！！！！
技巧：机试常用算法
Siumai's Blog
03-22 521
一、素数判断： 1、直接判断 o(n^1/2) bool isprime( int n ) { if( n < 2 ) return false; for( int i = 2; i <= sqrt(n); ++i ) if( n % i == 0 ) return false; return true; ...
机试算法
三木君的博客
04-15 415
计算机复试和公司入职考试很多会考算法，如果把计算机复试的基本掌握，算法题就总体很简单了。 算法分类： 1.暴力求解。 利用循环 2.贪心算法。 1）利用很明显的极限 2）不太明显的，但是局部不影响其他，递进推出最优解。比如旅行加油问题 3.数据结构 1）队列，做BFS. 因为BFS在距离都同的情况下，有最近的属性，所以可以做最短步骤搜索。比如解锁问题。java中的队列，和C++中的队列。 C++中的队列，queue.priority_queue。 优先队列...
机试基本算法笔记--搜索
lmix___的博客
08-29 144
枚举、广搜、深搜、递归
2018年复试算法题
qq_43699776的博客
03-14 4572
1.微信跳一跳 问题描述：最近很火的微信游戏跳一跳游戏规则如下：短跳得1分，跌落游戏结束，长跳得2分，并且长跳可连续累加，第一次2分，第二次4分，依次类推，若长中断则重新计分2分。 现给定0,1,2的组合序列，其中0：跌落 1：短跳成功 2：长跳成功 请你计算玩家当次游戏的合计得分。 输入格式：首先输入一个数字n代表当前游戏状态变化数，接着输入n个由0,1,2组合的数字，0代表结束。 输出格式：输出玩家当次游戏得分。 输入案例： 6 1 2 2 1 2 0 输出结果：10 #include<iostr
清华计算机考研历年复试机试集合.zip
最新发布
06-20
【标题】"清华计算机考研历年复试机试集合.zip"是一个包含清华大学计算机科学与技术专业考研复试阶段机试题目和解题思路的压缩包文件。这个集合可能是为了帮助备考的考生们熟悉考试格式、提高编程能力和算法理解而...
武汉大学 WOJ STARTER 题解 考研复试 机试
08-22
对于考研复试的机试环节，考生通常需要具备扎实的计算机基础知识，包括但不限于C/C++、Java等编程语言的掌握，以及对常见算法和数据结构的理解。这些题目可能涉及排序、搜索、图论、动态规划等经典算法，同时也可能...
计算机机试指南九度OJ机试题目解析复试机试参考.docx
10-12
【计算机机试指南九度OJ机试题目解析】这篇文档是针对计算机考研学生的机试复习资料，主要汇总了九度在线判题系统（九度OJ）中的常见机试题目类型和解题策略。虽然九度OJ已经下线，但这份文档仍然具有参考价值。以下...
北航-考研-上机-历年复试机试.zip
06-12
【标题】"北航-考研-上机-历年复试机试.zip" 提供的是北京大学航空航天学院研究生入学考试的历年上机复试题目集合。这个压缩包包含的资源是历年来的上机编程试题，主要针对计算机科学和技术相关专业的考生，旨在测试...
考研复试常见问题（算法篇）
李润泽的博客
05-15 2859
文章目录1.平衡二叉树和红黑树2.哈夫曼编码3.B+树4.排序算法5.查找算法 1.平衡二叉树和红黑树 【平衡二叉树】：又称为AVL树，是一种特殊的二叉排序树，它的左右子树都是平衡二叉树，且左右子树高度差的绝对值不大于1。将二叉树上结点的左子树深度减去右子树深度称为平衡因子BF，平衡二叉树上的平衡因子只可能是-1、0、1，否则二叉树就不是平衡的。 【红黑树】：是一种二叉查找树，但每个结点增加一个存储位表示结点颜色（非黑即红），通过对任何一条从根到叶子结点的路径各个结点着色方式的限制，红黑树确保没有一条路径
机试算法总结（待更新）
Mr_zhuo_的博客
03-12 1426
回溯法 通过读题完成下面三个步骤： 1)描述解的形式，定义一个解空间，它包含问题的所有解。 2)构造状态空间树。 3)构造约束函数（用于杀死节点）。 然后就要通过深度优先搜索思想完成回溯，完整过程如下： 1)设置初始化的方案（给变量赋初值，读入已知数据等）。 2)变换方式去试探，若全部试完则转(7)。 3)判断此法是否成功（通过约束函数），不成功则转(2)。 4)试探成功则前进一...
机试NOI：基本算法
宴夜小丑的博客
06-03 1587
NOI 1.11-2.5 基本算法学习，不断更新ing1.11 编程基础之二分查找NOI：7940 最接近的元素（经典二分法思想）：https://blog.csdn.net/wuzhenzi5193/article/details/80502639NOI：2806 二分法求函数的零点（二分法思想）：https://blog.csdn.net/wuzhenzi5193/article/detail...
2019年复试算法题
qq_43699776的博客
03-15 273
1.简单题：求和，最小值，最大值 2.二进制转换为十进制 #include<stdio.h> int main(){ char ch; int a=0; while(ch=getchar(),ch!='\n') a=a*2+(ch-'0'); printf("%d\n",a); return 0; } 3.打印n阶实心菱形 #include<stdio.h> #include<iostream> using namespace std; int mai
2017年北理复试上机题
热门推荐
A place to record sth.
03-14 1万+
历年北京理工大学复试上机题题目汇总：http://blog.csdn.net/u014552756/article/details/785058451、输入身份证号，通过计算比较校验位来判断身份证号是否正确。如，aaaaaayyyymmddxxsp共18位，其中：年份代码yyyy共4位。最后一位p为校验位。校验规则是：（1）对前17位数字的权求和 S=Sum(Ai*Wi)，i=0,...,16Ai...
复试准备_算法_part01
weixin_44092937的博客
05-01 83
1.给定两个字符串s和t，编写一个函数来判断t是否为a的字母异位词。 你可以假设字符串只包括小写字母。 思路：小写字母一共26个，我们可以设置长度为26的数组。将出现在字符串s中的字母加1，出现在字符串t中的字母减一。最后遍历数组，每个元素值为0即为异位词。 #include<stdio.h> #include<string.h> void fun1() { char ...
常见算法面试题
z_z_k的博客
11-16 831
文章目录一个数组，求连续最大的和问题举例问题解析代码整数反转问题举例问题解析代码回文数问题举例问题解析代码未完待续 一个数组，求连续最大的和 问题举例 数组 {1,-4,10,5,-10,23}, 求出当前数组中最大的和，10+5+ -10 +23 = 28 数组 {2,-10,4,9,-29,10}, 求出当前数组中最大的和，4+9=13 问题解析 已知数组，想求出连续最大和，先初始化最大值为数组第一个数字； 然后循环数组一直相加求连续和，每加完一个值，就用连续和 和 最大值进行比较，从新赋值；
从头开始学算法：考研机试题练习（C/C++）--基础知识
知行_那片天
09-02 727
最近重学c语言，刷的是胡凡写的《算法笔记》，这本书的题主要是面向考研机试和一般算法考试的，零基础入门，还不错，在此记录学习过程。本文回顾c语言的I/0操作和字符字符串操作等基础知识。
常用上机考试算法代码
qq_39031700的博客
04-26 407
图算法 DFS: const int MAXV=1000; const int INF=10000000000000; 1.邻接矩阵版 int n,G[MAXV][MAXV]; bool vis[MAXV]={false}; void DFS(int u,int depth){ vis[u]=true; for(int v=0;v<n;;v++){ if(vi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值