图论优题(1)

最新推荐文章于 2024-06-21 17:14:10 发布
最新推荐文章于 2024-06-21 17:14:10 发布
阅读量215 收藏 1
点赞数
文章标签： 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38291213/article/details/119139738
版权

图论优题

1.Computer

HDU - 2196
算法：树的直径，树形DP
注释：dist[i][0]表示向下最长距离，dist[i][1]表示向下次长距离，dist[i][2]表示反向最长距离
1）先按求树的直径的方法计算出每个节点向下的最长距离和次长距离，注意应该记录达到最长距离最经过的儿子节点，以方便后边方向距离的计算。状态转移公式为：

if(dist[u][0]<dist[v][0]+w)
{
longest[u]=v;
dist[u][1]=dist[u][0];
dist[u][0]=dist[v][0]+w;
}
else if(dist[u][1]<dist[v][0]+w)
dist[u][1]=dist[v][0]+w;

DP顺序为先计算儿子节点，再计算父节点。
2）在求该节点经过父节点的反向最长距离，注意不应该用父节点能到达的最大距离，因为可能出现重复路径。状态转移公式为：

if(v==longest[u])dist[v][2]=max(dist[u][2],dist[u][1])+w;
else dist[v][2]=max(dist[u][2],dist[u][0])+w;

DP顺序先计算父节点，再计算子节点。

#include<iostream>
#include<cstdio>
#include<cstring>
#define N 10010
#define ll long long
using namespace std;
int first[N],nex[N<<1],ord[N<<1],vul[N<<1],cnt;
ll dist[N][3],longest[N];
void add(int u,int v,ll w)
{
	nex[++cnt]=first[u];
	ord[cnt]=v;
	vul[cnt]=w;
	first[u]=cnt;
}
ll max(ll a,ll b)
{
	return a>b?a:b;
}
void dp1(int u,int father)
{
	//cout<<u<<endl;
	int i,v,w;
	for(i=first[u];i;i=nex[i])
	{
		v=ord[i];
		w=vul[i];
		if(v==father)continue;
		dp1(v,u);
		if(dist[u][0]<dist[v][0]+w)
		{
			longest[u]=v;
			dist[u][1]=dist[u][0];
			dist[u][0]=dist[v][0]+w;
		}
		else if(dist[u][1]<dist[v][0]+w)
			dist[u][1]=dist[v][0]+w;
	}
}
void dp2(int u,int father)
{
	int v,w,i;
	for(i=first[u];i;i=nex[i])
	{
		v=ord[i];
		w=vul[i];
		if(v==father)continue;
		if(v==longest[u])dist[v][2]=max(dist[u][2],dist[u][1])+w;
		else dist[v][2]=max(dist[u][2],dist[u][0])+w;
		dp2(v,u);
	}
}
int main()
{
	ll i,u,n,v,w;
	while(cin>>n&&n!=0)
	{
		memset(dist,0,sizeof(dist));
		memset(first,0,sizeof(first));
		memset(longest,0,sizeof(longest));
		cnt=0;
		for(u=2;u<=n;u++)
		{
			cin>>v>>w;
			add(u,v,w);
			add(v,u,w);
		}
		dp1(1,0);
		dp2(1,0);
		for(u=1;u<=n;u++)
		cout<<max(dist[u][2],dist[u][0])<<endl;
	}
	
	return 0;
}

2.Shichikuji and Power Grid

CF1245D
算法：最小生成树
注释：本题考验抽象思维

  • 将每个城市建造发电厂所需要的费用看做是次点到零点所的距离，然后依次计算每两个点之间建设路线的花费，将问题转化为最小生成树问题，因为包含零点，所以必定至少一个点由建设发电厂，由于最终结果是一棵树，所以必定每个点都有可能连接到发电厂。
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#define N 2010
#define M 5000010
#define ll long long 
using namespace std;
struct point{
	int x,y;
}p[N];
struct edge{
	int u,v;
	ll w;
}e[M],con[N];
int c[N],k[N],f[N],cnt;
int vn=0,build[N],en=0;
ll ans;
bool cmp(const edge &a,const edge &b)
{
	return a.w<b.w;
}
void init(int n)
{
	for(int i=0;i<=n;i++)
	f[i]=i;
}
int find(int u)
{
	if(f[u]==u)return u;
	return find(f[u]);
}
ll dis(int i,int j)
{
	return (abs(p[i].x-p[j].x)+abs(p[i].y-p[j].y));
}
int main()
{
	int n,m=0;
	
	cin>>n;
	init(n);
	
	for(int i=1;i<=n;i++)
		cin>>p[i].x>>p[i].y;
	for(int i=1;i<=n;i++)
	{
		cin>>c[i];
		e[m].u=i;
		e[m].v=0;
		e[m++].w=c[i];
	}
	for(int i=1;i<=n;i++)
		cin>>k[i];
	for(int i=1;i<=n;i++)
	{
		for(int j=i+1;j<=n;j++)
		{
			e[m].u=i;
			e[m].v=j;
			//cout<<i<<" "<<j<<" "<<dis(i,j)<<endl; 
			e[m++].w=dis(i,j)*(k[i]+k[j]);
		}
	}
	//cout<<m<<endl<<endl;
	sort(e,e+m,cmp);
	
	
	for(int i=0;i<m;i++)
	{
		//cout<<e[i].u<<" "<<e[i].v<<" "<<e[i].w<<endl;
		int u=find(e[i].u);
		int v=find(e[i].v);
		if(u!=v)
		{
			if(e[i].v==0)
			{
				build[++vn]=e[i].u;
			}
			else 
			{
				con[++en].u=e[i].u;
				con[en].v=e[i].v;
			}
			 
			f[u]=v;
			ans+=e[i].w;
			cnt++;
		}
		if(cnt==n)break;
	}
	cout<<ans<<endl;
	cout<<vn<<endl;
	for(int i=1;i<=vn;i++)
	cout<<build[i]<<" ";
	cout<<endl<<en<<endl;
	for(int i=1;i<=en;i++)
	cout<<con[i].u<<" "<<con[i].v<<endl;
	return 0;
 }

3.book of evil

Codeforces 337D
算法：树的直径，树形DP
注释：

  • 树的直径问题就是线性求多源最长(或最短)路径，或者求解树中的最长链，当然这都是在图是一棵树的基础上进行的。
  • 本题可以转化为求每个点到最远的受到伤害的点的距离，最终遍历所有点的最长距离，只要小于等于所给范围，就可以认定为可能放魔法书的点。
#include<iostream>
#include<cstdio>
#include<cstring>
#define N 100010
#define MINN -0x3f3f3f3f
using namespace std;
int dist[N][3],longest[N];
int first[N],nex[N<<1],ord[N<<1],cnt=0;
bool p[N];
int max(int a,int b)
{
	return a>b?a:b;
}
void add(int u,int v)
{
	nex[++cnt]=first[u];
	ord[cnt]=v;
	first[u]=cnt;
}
void dp1(int u,int father)
{
	int v,i;
	if(p[u])dist[u][0]=dist[u][2]=0;
	for(i=first[u];i;i=nex[i])
	{
		v=ord[i];
		if(v==father)continue;
		dp1(v,u);
		if(dist[u][0]<dist[v][0]+1)
		{
			longest[u]=v;
			dist[u][1]=dist[u][0];
			dist[u][0]=dist[v][0]+1;
		}
		else if(dist[u][2]<dist[v][0]+1)
		{
			dist[u][2]=dist[v][0]+1;
		}
	}
}
void dp2(int u,int father)
{
	int v,i;
	for(i=first[u];i;i=nex[i])
	{
		v=ord[i];
		if(v==father)continue;
		if(dist[v][0]+1==dist[u][0])
		{
			dist[v][2]=max(dist[u][2],dist[u][1])+1;
		}
		else 
			dist[v][2]=max(dist[u][0],dist[u][2])+1;
		dp2(v,u);
	}
}
int main()
{
	int n,m,d,i,u,v,x,tot=0;
	cin>>n>>m>>d;
	for(i=1;i<=n;i++)
	dist[i][0]=dist[i][1]=dist[i][2]=MINN;
	for(i=1;i<=m;i++)
	{
		cin>>x;
		p[x]=true;
	}
	for(i=1;i<n;i++)
	{
		cin>>u>>v;
		add(u,v);
		add(v,u);
	}
	dp1(1,0);
	dp2(1,0);
	//for(i=1;i<=n;i++)
	//cout<<dist[i][0]<<" "<<dist[i][1]<<" "<<dist[i][2]<<endl;
	for(i=1;i<=n;i++)
	{
		if(i==1)
		{
			if(max(dist[i][0],dist[i][1])<=d)tot++;
		}
		else if(max(dist[i][0],dist[i][2])<=d)tot++;
	}
	cout<<tot<<endl;
	return 0;
}

4.You Are Given a Tree

第一周提高 H - 8
算法：树的直径，树形DP
注释：

  • 因为是在给出的一棵树中找出三个点，所以三个点形成的三条边之间一定存在一个交点，当然如果三个点在同一条直线上，那么可能存在多个交点。问题可以最终转为求解每个点所能到达的最长，次长，次次长路径（由于是DP所以也能记录最终点或者路径），即为求解时树的直径时再增加一条次次长路径的判断。注意问题要求最终求得三个点互不相同，所以需要加一条判断。
#include<iostream>
#include<cstdio>
#include<cstring> 
#define N 200010
using namespace std;
int first[N],nex[N<<1],ord[N<<1],cnt;
int dist[N][4],p[N][4],longest[N],maxn,res[3];
void add(int u,int v)
{
	nex[++cnt]=first[u];
	ord[cnt]=v;
	first[u]=cnt;
}
void init(int n)
{
	int i;
	memset(dist,0,sizeof(dist));
	for(i=0;i<=n;i++)
	p[i][0]=p[i][1]=p[i][2]=p[i][3]=i;
}
int max(int a,int b)
{
	return a>b?a:b;
}
void dfs1(int u,int father)
{
	int v,i;
	for(i=first[u];i;i=nex[i])
	{
		v=ord[i];
		if(v==father)continue;
		dfs1(v,u);
		if(dist[u][0]<dist[v][0]+1)
		{
			longest[u]=v;
			dist[u][2]=dist[u][1];
			p[u][2]=p[u][1];
			dist[u][1]=dist[u][0];
			p[u][1]=p[u][0];
			dist[u][0]=dist[v][0]+1;
			p[u][0]=p[v][0]; 
		}
		else if(dist[u][1]<dist[v][0]+1)
		{
			dist[u][2]=dist[u][1];
			p[u][2]=p[u][1];
			dist[u][1]=dist[v][0]+1;
			p[u][1]=p[v][0];
		}
		else if(dist[u][2]<dist[v][0]+1)
		{
			dist[u][2]=dist[v][0]+1;
			p[u][2]=p[v][0];
		}
	}
}
void dfs2(int u,int father)
{
	int v,i;
	for(i=first[u];i;i=nex[i])
	{
		v=ord[i];
		if(v==father)continue;
		if(v==longest[u])
		{
			if(dist[u][3]>dist[u][1])
			{
				dist[v][3]=dist[u][3]+1;
				p[v][3]=p[u][3];
			}
			else
			{
				dist[v][3]=dist[u][1]+1;
				p[v][3]=p[u][1];
			}
		}
		else 
		{
			if(dist[u][3]>dist[u][0])
			{
				dist[v][3]=dist[u][3]+1;
				p[v][3]=p[u][3];
			}
			else 
			{
				dist[v][3]=dist[u][0]+1;
				p[v][3]=p[u][0];
			}
		}//dist[v][3]=max(dist[u][0],dist[u][3])+1;
		dfs2(v,u);
	}
}
bool judge(int u)
{
	if((p[u][0]!=p[u][1])&&((p[u][1]!=p[u][2])||(p[u][1]!=p[u][3]))&&((p[u][0]!=p[u][2])||(p[u][0]!=p[u][3])))
	return 1;
	else return 0;
}
int main()
{
	int n,u,v,i;
	cin>>n;
	init(n);
	for(i=1;i<n;i++)
	{
		cin>>u>>v;
		add(u,v);
		add(v,u);
	}
	dfs1(1,0);
	dfs2(1,0);
	for(int i=1;i<=n;i++)
	{
		//cout<<dist[i][0]<<" "<<dist[i][1]<<" "<<dist[i][2]<<" "<<dist[i][3]<<endl;
		if(maxn<dist[i][0]+dist[i][1]+max(dist[i][2],dist[i][3])&&judge(i))
		{
			maxn=dist[i][0]+dist[i][1]+max(dist[i][2],dist[i][3]);
			res[0]=p[i][0];
			res[1]=p[i][1];
			res[2]=(dist[i][2]>dist[i][3]?p[i][2]:p[i][3]);//当相等时，优先选择父节点 
		}
	}
	cout<<maxn<<endl;
	cout<<res[0]<<" "<<res[1]<<" "<<res[2]; 
	return 0;
}

5.Fire

UVA-11624
算法：BFS
注释：

  • 进行两次BFS，先将火燃烧的每个点的所需的时间预处理出来，在第二次BFS的时候多加一个判断即可
  • 注意：在修改代码时，应该修改全，上下相似的代码都要进行修改
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<cmath>
#define N 1010
using namespace std;
struct step{
	int x;
	int y;
	int s;
}temp;
queue<step>q;
char map[N][N];
bool vis[N][N];
int nx[4]={0,1,0,-1},ny[4]={1,0,-1,0},r,c,t,fmap[N][N];
void bfsf()
{
	step u,v;
	while(!q.empty())
	{
		u=q.front();
		//cout<<u.x<<" "<<u.y<<endl;
		q.pop();
		for(int i=0;i<=3;i++)
		{
			v.x=u.x+nx[i];
			v.y=u.y+ny[i];
			v.s=u.s+1;
			if(v.x==0||v.x>r||v.y==0||v.y>c)continue;
			else if(map[v.x][v.y]=='.'&&vis[v.x][v.y]==false)
			{
				vis[v.x][v.y]=true;
				fmap[v.x][v.y]=v.s; 
				q.push(v);
			}
		}
	}
}
int bfs(int sx,int sy)
{
	step u,v;
	
	vis[sx][sy]=true;
	u.x=sx;
	u.y=sy;
	u.s=0;
	q.push(u);
	
	while(!q.empty())
	{
		u=q.front();
		//cout<<u.x<<" "<<u.y<<":::::"<<endl;
		q.pop();		
		for(int i=0;i<=3;i++)
		{
			v.x=u.x+nx[i];
			v.y=u.y+ny[i];
			v.s=u.s+1;
			if(v.x==0||v.x>r||v.y==0||v.y>c)return v.s;
			else if(map[v.x][v.y]=='.'&&vis[v.x][v.y]==false)
			{
				vis[v.x][v.y]=true;
				//cout<<v.x<<" "<<v.y<<" "<<v.s<<endl;
				if(fmap[v.x][v.y]<=v.s)
				{
					//cout<<fmap[v.x][v.y]<<endl;
					continue;
				}
				q.push(v);
			}
		}
	}
	return -1;
}
void init()
{
	memset(vis,0,sizeof(vis));
	while(!q.empty())q.pop();
	
}
int main()
{
	//freopen("1.txt","r",stdin);
	//freopen("2.txt","w",stdout);
	cin>>t;
	int b=0;
	while(t--)
	{
		b++;
		init();
		memset(fmap,111,sizeof(fmap));
		int sx,sy;
		
		cin>>r>>c;
		for(int i=1;i<=r;i++)
		for(int j=1;j<=c;j++)
		{
			cin>>map[i][j];
			if(map[i][j]=='F')
			{
				fmap[i][j]=0;
				temp.x=i;
				temp.y=j;
				temp.s=0;
				q.push(temp);
			}
			if(map[i][j]=='J')
			{
				sx=i;
				sy=j;
			}
		}
		
		bfsf();
		init(); 
		int res=bfs(sx,sy);
		if(res==-1)cout<<"IMPOSSIBLE"<<endl;
		else cout<<res<<endl;
	}
	return 0;
 }

6.Monocycle

UVA-10047
算法：BFS
注释：

  • 变式的BFS，每个点有多个状态，包括颜色和朝向的不同都应该记录，看作是不同的点，每种状态的方向只有三种，向左转，向右转和向前走。其实就是抽象成图，状态做点，方向做边。
  • 注意：数组大小尽量开大一点，否则可能出现越界数组出现不同值的情况，在修改代码时，应该将代码修改全。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue> 
using namespace std;
struct state{
	int x,y,d,c;
	int s;
}s,t;

int f[26][26][4][5],n,m,nx[4]={-1,0,1,0},ny[4]={0,1,0,-1};
bool vis[26][26][4][5];//检查时应该注意数组的大小开的是否合适，尽量开大一点 
char map[26][26];
queue<state>q;
void init()
{
	memset(f,0,sizeof(f));
	memset(vis,0,sizeof(vis));
	while(!q.empty())q.pop();
}
void is_push(state v)
{
	if(vis[v.x][v.y][v.d][v.c]==0)
	{
		vis[v.x][v.y][v.d][v.c]=1;
		q.push(v);
	}
}
int bfs()
{
	state u,v;
	s.s=0;
	s.c=0;
	s.d=0;
	vis[s.x][s.y][s.d][s.c]=1;
	q.push(s);
	while(!q.empty())
	{
		u=q.front();
		q.pop();
		v.s=u.s+1;
		//向下一个方向转
		v.x=u.x;
		v.y=u.y;
		v.c=u.c;
		v.d=(u.d+5)%4;
		is_push(v);
		//向上一个方向转
		v.x=u.x;
		v.y=u.y;
		v.c=u.c;
		v.d=(u.d+3)%4;
		is_push(v);
		//向当前方向走一格
		
		v.x=u.x+nx[u.d];
		v.y=u.y+ny[u.d];
		v.c=(u.c+1)%5;
		v.d=u.d;
		if(v.x>0&&v.y>0&&v.x<=n&&v.y<=m&&map[v.x][v.y]!='#')
		{ 
			
			if(v.x==t.x&&v.y==t.y&&v.c==0)
			return v.s;
			is_push(v);
		}
	}
	return -1;
}
int main()
{
	int cnt=0; 
	while(cin>>n>>m&&n&&m)
	{
		cnt++;
		init();
		for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
		{
			cin>>map[i][j];
			if(map[i][j]=='S')
			{
				s.x=i;
				s.y=j;
			}
			if(map[i][j]=='T')
			{
				t.x=i;
				t.y=j;
			}
		}
		if(cnt!=1)cout<<endl;
		cout<<"Case #"<<cnt<<endl;
		int res=bfs();
		if(res!=-1)cout<<"minimum time = "<<res<<" sec"<<endl;
		else cout<<"destination not reachable"<<endl;
	}
	return 0;
}

7.糖果

LibreOJ - 2436
算法：拓扑排序，spfa，差分约束
注释：

  • 对于差分约束题目，需要使用spfa来做，根据大小关系，建图求最短路径。应该注意的是。首先建立虚源点指向所有点，求解最小值以及建立的是是正图时，求最长路，建立的昰负图时是求最短路，可以具体问题具体分析来看。当出现负环时说明不存在这种约束关系，所有由虚源点直接指向的值可以修改以得到不同的结果集合，可以将结果加上同一个数字也可以得到不同的结果集合。
  • 当差分约束的值为单一值，零或者一的时候，可以考虑使用缩点加拓扑排序的方式来做。
  • 本题目中，将符合条件一的，建立权值为0的双向边，条件二和四建立权值为1的单向边，条件三和五建立权值为0的单向边，然后建立一个指向所有点且权值为0的原点。需要注意的是，条件二和条件四的两个点不应该相同，若相同，直接判定为有负环。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue> 
#define ll long long
#define N 100010
#define K 100010
using namespace std;
struct edge{
	int next;
	int to;
	ll w;
}e[K<<2];
ll first[N],cnt,dis[N],num[N];
bool vis[N];
queue<int>q;
void add(int u,int v,int w)
{
	e[++cnt].next=first[u];
	e[cnt].to=v;
	e[cnt].w=w;
	first[u]=cnt;
}
void init()
{
	cnt=0;
	memset(first,-1,sizeof(first));
	memset(dis,0,sizeof(dis));
	memset(vis,0,sizeof(vis));
	memset(num,0,sizeof(num));
	while(!q.empty())q.pop();
	
}
int spfa(int s,int n)
{
	dis[s]=0;
	vis[s]=1;
	num[s]++;
	q.push(s);
	
	int u,v,w;
	
	while(!q.empty())
	{
		u=q.front();
		vis[u]=0;
		q.pop();
		
		for(int i=first[u];i+1;i=e[i].next)
		{
			v=e[i].to;
			w=e[i].w;
			if(dis[v]<dis[u]+w)
			{
				dis[v]=dis[u]+w;
				if(!vis[v])
				{
					q.push(v);
					vis[v]=1;
				} 
				num[v]++;
				if(num[v]>n)return -1;
			}
		}
	}
	return 1;
}
int min(int a,int b)
{
	return a<b?a:b;
}
int main()
{
	//freopen("3.in","r",stdin); 
	init();
	ll n,k,x,a,b,tot=0,minn=0;
	cin>>n>>k;
	for(int i=0;i<k;i++)
	{
		cin>>x>>a>>b;
		if(x==1)
		{
			add(b,a,0);
			add(a,b,0);
		}
		else if(x==2) 
		{
			if(a==b){cout<<-1;return 0;}//特殊情况的考虑 
			add(a,b,1);
		}
		else if(x==3) add(b,a,0);
		else if(x==4)
		{
			 if(a==b){cout<<-1;return 0;}
			 add(b,a,1);
		}
		else if(x==5) add(a,b,0);
	}
	for(int i=n;i>=1;i--)
	add(0,i,1);
	
	
	
	if(spfa(0,n)==-1)
		cout<<-1;
	else 
	{
		for(int i=1;i<=n;i++)
			tot+=dis[i];
		//cout<<n<<" "; 
		cout<<tot;
	}
	return 0;
}

8.Guess

UVALive - 4255
算法：前缀和，差分约束，拓扑排序
注释：

  • 本题可以将前缀和看做一个元素，这样，符号矩阵中的每个符号可以表示成前缀和之差:S[i][j]=sum[j]-sum[i-1]，求出每个sum后可以计算每个元素的值。
  • 加号和减号建立边关系，等号不建立。可以得到几组不等式，转化为差分约束问题，由于两个元素的差都是与0相比，可以抽象成边的权值为零，这样可以利用拓扑排序来解决这个问题。
  • 注意：最后求出前缀和的从小到大的关系，应该利用零值确定每个前缀和的正负号。同样为差分约束系统，可以类比糖果一题。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
#define N 20
using namespace std;
struct edge{
	int next,to;
}e[N*N*2];
struct point{
	int num,pri;
}q[N];
int sum[N],n,first[N],cnt,inum[N];
char pos[N][N];
int head,tail;
void add(int u,int v)
{
	e[++cnt].next=first[u];
	e[cnt].to=v;
	first[u]=cnt;
}
void init()
{
	memset(first,-1,sizeof(first));
	memset(sum,0,sizeof(sum));
	memset(inum,0,sizeof(inum));
	head=tail=cnt=0;
}
int main()
{
	int t,x,zero;
	point u,v;
	cin>>t;
	while(t--)
	{
		init();
		cin>>n;
		for(int i=1;i<=n;i++)
		for(int j=i;j<=n;j++)
		cin>>pos[i][j];
		
		for(int i=1;i<=n;i++)
		{
			for(int j=i;j<=n;j++)
			{
				if(pos[i][j]=='+')
				{
					add(i-1,j);
					inum[j]++;
				}
				else if(pos[i][j]=='-')
				{
					add(j,i-1);
					inum[i-1]++;
				} 
			}
		}
		/*for(int i=0;i<=n;i++)
		{
			cout<<i<<":";
			for(int j=first[i];j+1;j=e[j].next)
			cout<<e[j].to<<" ";
			cout<<endl;
		}*/
		for(int i=0;i<=n;i++)
		if(!inum[i])
		{
			q[tail].num=i;
			q[tail].pri=0;
			tail++;
		}
		point temp;
		while(head<tail)
		{
			u=q[head++];
			for(int i=first[u.num];i+1;i=e[i].next)
			{
				v.num=e[i].to;
				inum[v.num]--;
				if(!inum[v.num])
				{
					v.pri=u.pri+1;
					q[tail++]=v;
				}
			}
		}
		for(int i=0;i<=n;i++)
			if(q[i].num==0)
			{
				zero=i;
				break;
			}
		
		for(int i=zero-1;i>=0;i--)
		{
			if(q[i].pri!=q[i+1].pri)
			sum[q[i].num]=sum[q[i+1].num]-1;
			else 
			sum[q[i].num]=sum[q[i+1].num];
		}
		for(int i=zero+1;i<=n;i++)
		{
			if(q[i].pri!=q[i-1].pri)
			sum[q[i].num]=sum[q[i-1].num]+1;
			else 
			sum[q[i].num]=sum[q[i-1].num];
		}
		for(int i=1;i<=n;i++)
		{
			cout<<sum[i]-sum[i-1]<<" ";
		}
		cout<<endl;
	}
	return 0;
}

9.Knights of the Round Table

UVALive - 3523
算法：双连通分量，割点问题
注释：

  • 本题比较考量图论的基础知识和分析。将骑士看做点，可以相邻的看做无向边，本题其实是求解不在任何一个简单奇圈上的点的个数。
  • 简单圈上的点一定处于双连通分量上，为保证存在简单奇圈，该双连通分量一定不是二分图（无向图是二分图当且仅当不存在奇圈）。此时剩下一个问题，就是如果点V在双连通分量上，是否一定在简单奇圈上？想给出答案是肯定的
  • 假设U1和U2在简单奇圈上，一定存在两条不相交路径相互到达，且长度一定是一奇一偶，从V也一定存在两条不相交路径到达U1和U2，所以V,U1,U2一定在同一个简单奇圈中。所以最终问题转化为求解不在任何一个不是二分图的双连通分量中的点的个数。
    在这里插入图片描述
#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<stack>
#define N 1010
#define M 1000010

using namespace std;
struct edge{
	int u,v;
};
int n,m,bccno[N],pre[N],low[N],bcc_cnt,dfs_clock,color[N]; //注意变量类型 
bool A[N][N],iscut[N],odd[N];
vector<int>G[N],bcc[N];
stack<edge>s;
void init()
{
	memset(A,0,sizeof(A));
	memset(bccno,0,sizeof(bccno));
	memset(pre,0,sizeof(pre));
	memset(low,0,sizeof(low));
	memset(iscut,0,sizeof(iscut));
	memset(color,0,sizeof(color));
	memset(odd,0,sizeof(odd));
	for(int i=1;i<=n;i++)
	G[i].clear();
	while(!s.empty())s.pop();
	bcc_cnt=dfs_clock=0;
}
int dfs(int u,int fa)
{
	int lowu=pre[u]=low[u]=++dfs_clock;
	int child=0;
	for(int i=0;i<G[u].size();i++)
	{
		int v=G[u][i];
		edge e=(edge){u,v};
		if(!pre[v])
		{
			s.push(e);
			int lowv=dfs(v,u);
			lowu=min(lowu,lowv);
			child++;
			
			if(lowv>=pre[u])
			{
				iscut[u]=1;
				bcc_cnt++;
				bcc[bcc_cnt].clear();
				for(;;)
				{
					edge x=s.top();s.pop();
					if(bccno[x.u]!=bcc_cnt)
					{
						bccno[x.u]=bcc_cnt;
						bcc[bcc_cnt].push_back(x.u);
					}
					if(bccno[x.v]!=bcc_cnt)
					{
						bccno[x.v]=bcc_cnt;
						bcc[bcc_cnt].push_back(x.v);
					}
					if(x.u==u&&x.v==v)break;
				}
			}
		}
		else if(pre[v]<pre[u]&&v!=fa)
		{
			s.push(e);
			lowu=min(lowu,pre[v]);
		}
	}
	if(fa==0&&child==1)iscut[u]=0;
	low[u]=lowu;
	return lowu;
}
void find_bcc(int n)
{
	for(int i=1;i<=n;i++)
	if(!pre[i])dfs(i,0);
}
bool partite(int u,int cnt)
{
	//cout<<u<<endl;
	//for(int i=1;i<=n;i++)
	//cout<<color[i]<<" ";
	//cout<<endl;
	for(int i=0;i<G[u].size();i++)
	{
		int v=G[u][i];
		if(bccno[v]!=cnt)continue;
		if(color[u]==color[v])return false;
		if(color[v]==0)
		{
			color[v]=3-color[u];
			if(!partite(v,cnt))return false;
		} 
	}
	return true;
}
int main()
{
	//freopen("1.txt","w",stdout);
	int u,v;
	bool flag=false;
	while(scanf("%d%d",&n,&m)!=EOF&&(n||m))
	{
		init();
		for(int i=0;i<m;i++)
		{
			scanf("%d%d",&u,&v);
			A[u][v]=A[v][u]=1;
		}
		for(int i=1;i<=n;i++)
		{
			//G[i].clear();
			for(int j=i+1;j<=n;j++)
			if(!A[i][j])
			{
				G[i].push_back(j);
				G[j].push_back(i);
			}
		}
		find_bcc(n);
		
		for(int i=1;i<=bcc_cnt;i++)
		{
			//cout<<i<<":";
			//if(bcc[i].size()<=2)continue;
			memset(color,0,sizeof(color));
			for(int j=0;j<bcc[i].size();j++)
			{
				bccno[bcc[i][j]]=i;
				//color[bcc[i][j]]=0;
			//	cout<<bcc[i][j]<<" ";
			}
			//cout<<endl;
			color[bcc[i][0]]=1;
			
			if(!partite(bcc[i][0],i))
			{
				//cout<<i<<endl;
				for(int j=0;j<bcc[i].size();j++)
				odd[bcc[i][j]]=1;
			}
		}
		int ans=n;
		for(int i=1;i<=n;i++)
		if(odd[i])ans--;
		cout<<ans<<endl;
	}
	return 0;
}

10.Mining Your Own Business

UVALive - 5135
算法：双连通分量，割点割边
注释：

  • 显然，太平井不应该建在割点处，求解所有双连通分量，如果一个双连通分量有一个割点，那么只需建立一个太平井，如果有两个割点，不需要建立太平井，如果没有割点（这种情况只可能出现一次），需要建立两个。
  • 求解方案的时候，割点不应该成为选择的可能。
#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<stack>
#define N 100010
#define ll long long
using namespace std;
struct edge{
	int u,v;
};
int dfs_clock,bcc_cnt,pre[N],low[N],bccno[N];
bool iscut[N];
vector<int>G[N],bcc[N];
stack<edge>s;
void init(int n)
{
	memset(pre,0,sizeof(pre));
	memset(low,0,sizeof(low));
	memset(bccno,0,sizeof(bccno));
	memset(iscut,0,sizeof(iscut));
	while(!s.empty())s.pop();
	for(int i=1;i<=N;i++)//初始化一定要完整 
		G[i].clear();
	dfs_clock=bcc_cnt=0;
}
int dfs(int u,int fa)
{
	int lowu=pre[u]=low[u]=++dfs_clock;
	int child=0;
	for(int i=0;i<G[u].size();i++)
	{
		int v=G[u][i];
		edge e=(edge){u,v};
		if(!pre[v])
		{
			s.push(e);
			int lowv=dfs(v,u);
			lowu=min(lowu,lowv);
			child++;
			
			if(lowv>=pre[u])
			{
				iscut[u]=1;
				bcc_cnt++;
				bcc[bcc_cnt].clear();
				for(;;)
				{
					edge x=s.top();s.pop();
					if(bccno[x.u]!=bcc_cnt)
					{
						bccno[x.u]=bcc_cnt;
						bcc[bcc_cnt].push_back(x.u);
					}
					if(bccno[x.v]!=bcc_cnt)
					{
						bccno[x.v]=bcc_cnt;
						bcc[bcc_cnt].push_back(x.v);
					}
					if(x.u==u&&x.v==v)break;
				}
				//cout<<u<<" "<<v<<endl;
			}
		}
		else if(pre[v]<pre[u]&&v!=fa)
		{
			s.push(e); 
			lowu=min(lowu,pre[v]);
		}
	}
	if(fa==0&&child==1)iscut[u]=0;
	low[u]=lowu;
	return lowu;
}
void find_bcc(int n)
{
	for(int i=1;i<=n;i++)
	if(!pre[i])dfs(i,0);
}
int main()
{
	int m,n,u,v,t=0;
	while(scanf("%d",&m)!=EOF&&m)
	{
		t++;
		ll ans=0,tot=1;
		n=0;//n需要初始化 
		init(m);
		for(int i=1;i<=m;i++)
		{
			scanf("%d%d",&u,&v);
			G[u].push_back(v);
			G[v].push_back(u);
			n=max(n,max(u,v));
		}
		//cout<<endl;
		find_bcc(n);
		
		for(int i=1;i<=bcc_cnt;i++)
		{
			ll num=0;
			//cout<<i<<":";
			for(int j=0;j<bcc[i].size();j++)
			{
				u=bcc[i][j];
			//	cout<<u<<" ";
				if(iscut[u])num++;
			}
			//cout<<endl; 
			if(num==1)
			{
				ans++;
				tot=tot*(ll)(bcc[i].size()-1);
			}
		}
		if(bcc_cnt==1)
		{
			ans=2;
			tot=(ll)bcc[1].size()*(bcc[1].size()-1)/2; 
		}
		cout<<"Case "<<t<<": "<<ans<<" "<<tot<<endl;
	}
	return 0;
}

11.Proving Equivalences

UVALive - 4287
算法：强连通分量，拓扑排序，缩点
注释：

  • 首先求出所有强连通分量，因为可以相互到达，缩为一点，最终形成几个DAG图。
  • DAG的两条重要性质：

性质一：DAG中所有入度不为0的点，一定可以从某个入度为0的点出发可达。
性质二：从DAG上任何一个点出发不断往前走必然终止于一个出度为0的点。

  • 也就是说从所有入度为零的点出发一定可以走遍边到达所有出度为零的点，只需要将所有出度为零的点与入度为零的点相连即可，可以将每个DAG出度为零的点连向下一个DAG入度为零的点,两两相连，形成环路，设a为入度为零的点个数，b为出度为零的点的个数，max(a,b)即为最终结果。
/*DAG:有向无环图*/

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<stack>
#define N 20010
using namespace std;
vector<int>G[N],scc[N],G2[N];
int pre[N],low[N],dfs_clock,sccno[N],scc_cnt,exp[N],imp[N];
stack<int>s;
void init(int n)
{
	dfs_clock=scc_cnt=0;
	memset(pre,0,sizeof(pre));
	memset(low,0,sizeof(low));
	memset(sccno,0,sizeof(sccno));
	memset(exp,0,sizeof(exp));
	memset(imp,0,sizeof(imp));
	while(!s.empty())s.pop();
	for(int i=1;i<=n;i++)
	{
		G[i].clear();
		scc[i].clear();
		G2[i].clear();
	}
}
int dfs(int u)
{
	//cout<<u<<endl;
	low[u]=pre[u]=++dfs_clock;
	s.push(u);
	
	for(int i=0;i<G[u].size();i++)
	{
		int v=G[u][i];
		//cout<<v<<"--"<<pre[v]<<endl;
		if(!pre[v])
		{
			dfs(v);
			low[u]=min(low[v],low[u]);
		}
		else if(!sccno[v])
		{
			low[u]=min(low[v],low[u]);
		}
	}
	if(low[u]==pre[u])
	{
		scc_cnt++;
		while(1)
		{
			int v=s.top();s.pop();
			sccno[v]=scc_cnt;
			scc[scc_cnt].push_back(v);
			if(v==u)break;
		}
	}
} 
void find_scc(int n)
{
	for(int i=1;i<=n;i++)
	if(!pre[i])dfs(i);
}
int main()
{
	int t,n,m,u,v;
	scanf("%d",&t);
	while(t--)
	{
		int a=0,b=0;
		scanf("%d%d",&n,&m);
		init(n);
		for(int i=1;i<=m;i++)
		{
			scanf("%d%d",&u,&v);
			G[u].push_back(v);
		}
		
		
		find_scc(n);
		
		
		for(u=1;u<=n;u++)
		{
			for(int j=0;j<G[u].size();j++)
			{
				v=G[u][j];
				if(sccno[v]!=sccno[u])
				{
					exp[sccno[u]]++;
					imp[sccno[v]]++;
				}
			}
		}
		for(int i=1;i<=scc_cnt;i++)
		{
			if(!exp[i])a++;
			if(!imp[i])b++;
		}
		if(scc_cnt==1)
		cout<<0<<endl;
		else cout<<max(a,b)<<endl;
	}
	return 0;
}

12.The Largest Clique

UVA - 11324
算法：缩点，强连通分量，拓扑排序，线性DP
注释：

  • 求解强连通分量进行缩点，得到DAG图，求最长的一条链，线性动态规划
#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<stack>
#include<queue>
#define N 1010
using namespace std;
int pre[N],low[N],dfs_clock,sccno[N],scc_cnt,imp[N],num[N],maxn;
bool vis[N];
vector<int>G[N],T[N],scc[N];
stack<int>s;
queue<int>q;
void init(int n)
{
	memset(pre,0,sizeof(pre));
	memset(low,0,sizeof(low));
	memset(sccno,0,sizeof(sccno));
	memset(imp,0,sizeof(imp));
	memset(vis,0,sizeof(vis));
	memset(num,0,sizeof(num)); 
	maxn=dfs_clock=scc_cnt=0;
	for(int i=0;i<=n;i++)
	{
		G[i].clear();
		T[i].clear();
		scc[i].clear();
	}
	while(!s.empty())s.pop();
	while(!q.empty())q.pop();
}
void dfs(int u)
{
	//cout<<u<<endl;
	pre[u]=low[u]=++dfs_clock;
	s.push(u);
	for(int i=0;i<G[u].size();i++)
	{
		int v=G[u][i];
		if(!pre[v])
		{
			dfs(v);
			low[u]=min(low[u],low[v]);
		}
		else if(!sccno[v])
		{
			low[u]=min(low[u],low[v]);
		}
	}
	if(pre[u]==low[u])
	{
		scc_cnt++;
		while(1)
		{
			int v=s.top();
			s.pop();
			sccno[v]=scc_cnt;
			scc[scc_cnt].push_back(v);
			if(v==u)break;
		}
	}
}
void find_scc(int n)
{
	for(int i=1;i<=n;i++)
	if(!pre[i])
		dfs(i);
}
void tupo()
{
	for(int i=1;i<=scc_cnt;i++)
	{
		if(!imp[i])
		q.push(i);
		num[i]=scc[i].size();
		maxn=max(maxn,num[i]);
	}
	int u,v;
	
	while(!q.empty())
	{
		u=q.front();
		q.pop();
		for(int i=0;i<T[u].size();i++)
		{
			v=T[u][i];
			num[v]=max(num[v],num[u]+(int)scc[v].size());
			maxn=max(maxn,num[v]);
			imp[v]--;
			if(!imp[v])q.push(v);
		}
	}
}
int main()
{
	//freopen("1.txt","r",stdin);
	//freopen("2.txt","w",stdout);
	int t,n,m,u,v;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d",&n,&m);
		//if(t==9)cout<<n<<" "<<m<<endl;
		init(n);
		for(int i=1;i<=m;i++)
		{
			scanf("%d%d",&u,&v);
			//if(t==9)cout<<u<<" "<<v<<endl;
			G[u].push_back(v);
		}
		
		find_scc(n);
		
		for(u=1;u<=n;u++)
		{
			for(int j=0;j<G[u].size();j++)
			{
				v=G[u][j];
				if(sccno[u]!=sccno[v])
				{
					imp[sccno[v]]++;
					T[sccno[u]].push_back(sccno[v]);
				}
			}
		}
		
		
		tupo();
		
		cout<<maxn<<endl;
	}
	return 0;
}

13.Now or later

UVALive - 3211
算法：dfs，2-SET问题，二分

  • 2-SET问题解决同差分约束系统一样，是解决给定条件后，判断条件是否能够满足的问题，只不过2-STE问题中是给定两个事件为真为假，(只要是事件有两种情况即可)，建立反向变关系枚举事件可能的情况得到答案。
  • 本题中最后提到要求时间间隔的最小值应尽量大，很自然的想到是个二分，可以考虑枚举最小的时间间隔，然后作为条件两两个飞机建立落地的关系，2-SET问题。
  • 注意：初始化2-SET的的图时，应该初始化2*n；时间复杂度是O(n^2logT)
#include<iostream>
#include<cstdio>
#include<cmath>
#include<vector>
#include<stack>
#include<cstring>
#define N 2010 
using namespace std;
struct TwoSET{
	bool mark[N<<1];
	vector<int>G[N<<1];
	stack<int>s;
	int n;
	
	void init(int n)
	{
		this->n=n;
		memset(mark,0,sizeof(mark));
		for(int i=0;i<n*2;i++)G[i].clear();//注意初始化时应该初始化的点 
	}
	
	void add_clause(int x,int xval,int y,int yval)
	{
		x=x*2+xval;
		y=y*2+yval;
		G[x^1].push_back(y);
		G[y^1].push_back(x);
	}
	
	bool dfs(int u)
	{
		if(mark[u^1])return false;
		if(mark[u])return true;
		
		mark[u]=true;
		s.push(u);
		
		for(int i=0;i<G[u].size();i++)
		if(!dfs(G[u][i]))return false;
		
		return true;
	}
	
	bool solve()
	{
		for(int i=0;i<n*2;i+=2)
		{
			if(!mark[i]&&!mark[i+1])
			{
				while(!s.empty())s.pop();
				if(!dfs(i))
				{
					while(!s.empty())
					{
						mark[s.top()]=false;
						s.pop();
					}
					if(!dfs(i+1))return false;
				}
			}
		}
		return true;
	}
};
int n,T[N][2];
TwoSET solver;

bool test(int diff)
{
	solver.init(n);
	for(int i=0;i<n;i++)for(int a=0;a<2;a++)
		for(int j=i+1;j<n;j++)for(int b=0;b<2;b++)
		if(abs(T[i][a]-T[j][b])<diff)solver.add_clause(i,a^1,j,b^1);
	return solver.solve(); 
}

int main()
{
	int l,r;
	while(scanf("%d",&n)==1&&n)
	{
		l=r=0;
		
		for(int i=0;i<n;i++)
		for(int j=0;j<2;j++)
		{
			scanf("%d",&T[i][j]);
			r=max(r,T[i][j]);
		}
		while(l<r)
		{
			int mid=(l+r+1)>>1; 
			if(test(mid))l=mid;
			else r=mid-1;
		}
		
		cout<<r<<endl;
	}
	return 0;
}

14.Astronauts

UVALive - 3713
算法：2-SET
注释：

  • 典型的2-SET问题，设两个宇航员相互讨厌i和j，如果两人是同类型的，那么条件是 非xi||非xj ，如果不是同种类型的则应由两个条件 非xi||非xj 和 xi||xj
  • 时间复杂度分析，由于是DFS所以对时间贡献是递归和循环，所以时间复杂度为O(max(n,2m))
#include<iostream>
#include<cstdio>
#include<stack>
#include<vector>
#include<cstring>
#define N 100010
#define ll long long
using namespace std;

struct TwoSET{
	int n;
	bool mark[N<<1];
	vector<int>G[N<<1];
	stack<int>s;
	
	void init(int n)
	{
		this->n=n;
		memset(mark,0,sizeof(mark));
		for(int i=0;i<n*2;i++)G[i].clear();
	}
	
	void add_clause(int x,int xtype,int y,int ytype)
	{
		x=x*2;
		y=y*2;
		if(xtype==ytype)
		{
			//cout<<"相同"<<endl; 
			G[x].push_back(y^1);
			G[y].push_back(x^1);
			G[x^1].push_back(y);
			G[y^1].push_back(x);
		}
		else 
		{
			//cout<<"不相同"<<endl;
			G[y^1].push_back(x);
			G[x^1].push_back(y);
			
		}
	}
	
	bool dfs(int u)
	{
		if(mark[u^1])return false;
		if(mark[u])return true;
		
		mark[u]=true;
		s.push(u);
		
		for(int i=0;i<G[u].size();i++)
		if(!dfs(G[u][i]))return false;
		
		return true;
	}
	
	bool solve()
	{
		for(int i=0;i<2*n;i+=2)
		{
			if(!mark[i]&&!mark[i^1])
			{
				while(!s.empty())s.pop();
				if(!dfs(i))
				{
					while(!s.empty())
					{
						mark[s.top()]=false;
						s.pop();
					}
					if(!dfs(i+1))return false;
				}
			}
		}
		return true;
	}
};
TwoSET solver;
ll age[N],type[N],n,m;

int main()
{
	int x,y;
	while(scanf("%d%d",&n,&m)==2&&(n+m))
	{
		ll tot=0;
		for(int i=0;i<n;i++)
		{
			type[i]=0;
			scanf("%d",&age[i]);
			tot+=age[i];
		}
		solver.init(n);
		
		
		for(int i=0;i<n;i++)
		{
			if(age[i]*n>=tot)type[i]=1;
			else type[i]=2; 
		}
		
		for(int i=0;i<m;i++)
		{
			cin>>x>>y;
			solver.add_clause(x-1,type[x-1],y-1,type[y-1]);
		}
		if(solver.solve())
		{
			for(int i=0;i<n;i++)
			{
				if(solver.mark[i*2])
				printf((type[i]==1?"A\n":"B\n"));
				else if(solver.mark[i*2+1])
				printf("C\n");
			}
		}
		else printf("No solution.\n");
	}
	return 0;
}

15.Claw Decomposition

UVA - 11396
算法：二分图判定
注释：

  • 每个爪子可以看做一个点加三条边，当一个点作为一个爪的时候，相邻的点不能作为爪，当一个点不作为爪的时候，相邻的点必须作为爪，典型的二分图问题。
#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#define N 310
using namespace std;
vector<int>G[N];
int n,color[N];
void init(int n)
{
	for(int i=0;i<=n;i++)
	{
		G[i].clear();
		color[i]=0;
	}
}
bool bipartite(int u)
{
	for(int i=0;i<G[u].size();i++)
	{
		int v=G[u][i];
		if(color[v]==color[u])return false;
		if(!color[v])
		{
			color[v]=3-color[u];
			if(!bipartite(v))return false;
		}
	}
	return true;
}
int main()
{
	//freopen("1.txt","w",stdout);
	int u,v;
	while(scanf("%d",&n)&&n)
	{
		init(n);
		while(scanf("%d%d",&u,&v)&&(u+v))
		{
			G[u].push_back(v);
			G[v].push_back(u);
		}
		color[1]=1;
		if(bipartite(1))printf("YES\n");
		else printf("NO\n");
	}
	return 0;
}
601tyl
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
图论问题建模讨论汇总
smilejiasmile的博客
06-24 1630
图论问题建模讨论汇总 一、骑士巡游 Knight's Tour 在8x8的国际象棋盘上某一位置上放置一个棋子马（亦称骑士） ， 然后采用国际象棋中“马走日字”的规则前进， 要求经过棋盘上每个小格子一次且仅一次。其中骑士一步可以移动的位置，走日字如下图所示： 实际上根据是否要求棋子马最终回到出发点又可以把骑士巡游问题分为骑士巡游道路问题和骑士巡游回路问题 ...
图与图论算法(1).pptx
02-12
* 好处：某些题的约束下不存在可以卡掉 SPFA 的数据，好写，一般情况下比较快，可以做负边权，可以找负环并查集 * 坏处：本质 Bellman-Ford，是平方级别，任何优化（SLF、LLL）都可以被卡掉（甚至指数），越来越多的...
图论优题(2)
qq_38291213的博客
10-05 231
图论优题21.Doves and bombs [UVA - 10765](https://vjudge.net/problem/UVA-10765)2.Wedding [UVA - 11294](https://vjudge.net/problem/UVA-11294) 1.Doves and bombs UVA - 10765 算法：割点，割边 注释： 给定一个无向图，求解每个点可以作为几个双连通分量的割点，注意对遇特殊点的判断，当祖先节点没有或者有一个儿子的时候，可以作为一个连通分量的割点；当祖先
图论练习题
雲泥有別 尘亦生辉
06-24 1647
图论练习题标签（空格分隔）： ACM 图论 综合第一部分：最短路1.poj1062 昂贵的聘礼（中等） 此题是个经典题目；用Dijkstra即可；但是其中的等级处理需要一定的技巧； 要理解好那个等级制度；这个处理好，基本就是裸体Dijkstra； 8876888 bobo0906 1062 Accepted 268K 0MS C++ 2007B 201
图论神仙题大赏
weixin_30886233的博客
08-12 137
BZOJ 3445 Roadblock 先跑一边最短路,然后枚举最短路上的每条边,将路径翻倍然后跑Dijstra. 因为不在最短路径上的边没用贡献,然后最短路径最长为 n−1 复杂度 O(nmlogm) BZOJ 1579 道路升级 两维：k使用了多少次更新，u最短路ww咱可以跑dp？ 分层图，第一层：原图，第二层内部：原图，然后从第一层点u向第二层点v连一条长度为0的边，从第二层点...
PKU图论基础题(转)
12-15 481
PKU图论基础题POJ 2449 Remmarguts’ Date(中等) http://acm.pku.edu.cn/JudgeOnline/problem?id=2449 题意：经典问题：K短路 解法：dijkstra+A*(rec)，方法很多 相关：http://acm.pku.edu.cn/JudgeOnline/showcontest?contest_id=1144 该题亦放在搜
Codeforces 图论tag题合集（1）
HanshinZone的博客
05-24 2349
Codeforce 图论tag题 2021.5 CR#693（div3）———— G. Moving to the Capital （树上DP） There are n cities in Berland. The city numbered 1 is the capital. Some pairs of cities are connected by a one-way road of length 1. Before the trip, Polycarp for each city found out
图论思维习题
qq_17080419的博客
09-14 207
CF1339D. Edge Weight Assignment 链接：https://codeforces.com/contest/1339/problem/D 题意：给定一颗 n 个节点的树，让你为 n -1 条边分配权值，使得任意两个叶节点之间的边权异或值为 0 。问最少和最多能分配多少个不同的权值。 思路： 最少：可以发现路径长度为偶数的话，可以设为以同一个数。奇数的话，就至少需要 3 个数。因此若叶节点两两之间的距离为偶数，那么答案就是 1，否则为 3 。 最多：可以发现如果两个叶节点距离为 2，
【图论杂题】：B.road [Floyed 倍增]
BLNG
08-06 102
题目： 团队链接：road 题面： 给定nnn个点mmm条边的有向图，单位时间内可经过2k2^k2k条边(k∈N∗k \in N^*k∈N∗)，求从点111到点nnn耗费的最少时间 n&lt;=50,m&lt;=10000n&lt;=50,m&lt;=10000n<=50,m<=10000, 数据保证最优解路径长度&lt;=maxlongint&...
【数据结构】图论
sight_720的博客
07-27 931
图论初步
图论考查的总结（1）
2301_81408620的博客
05-27 506
第一位客人肯定把他的喜爱口味全会取走，为了让结果更优，接下来的客人的喜爱口味与之有重合，这样他就只会取走一个零食，以此类推……于是建一个n个点m条边的图。对于每一个连通块如上述处理，假设该连通块有 x个点，那么该连通块中最终有 x-1位客人可以取走零食。3.第一问求选择的道路数，因为只有“保证连通”一个条件优先级在“道路尽量少”之上，不难看出直接输出n-1（一个N个点的联通图最少有n-1条边）。匈牙利算法考查的是二分图的最大匹配问题（脑抽了）1.本题考查的是并查集（本人考虑的是匈牙利算法 一--一）
14初复试真题1
08-08
7. **算法时间复杂度比较**：O符号表示算法的渐进时间复杂度，讨论是否存在更优算法的目的是寻找时间复杂度更低的排序或查找算法，如快速排序、归并排序等。 【算法题】 1. **二叉链表的合并**：如果两个链表是...
ch7习题1
08-03
【哈密顿环问题】哈密顿环问题是一个经典的图论问题，要求在无向图中找到一个经过每个顶点恰好一次并返回起点的闭合路径。在这个问题中，我们需要将解空间表示为树结构，其中每个节点代表图中某条路径的状态，边则...
深圳杯C题1
08-03
利用加权无向拓扑图数据结构，将复杂的配电网结构转化为图论问题，通过最小路和等值法的混合算法评估负荷点及配电系统的可靠性。在这一过程中，对拓扑信息进行了灵敏度分析，提供定性与定量的计算方式，以理解和应对...
常见：算法工程师面试题1
08-08
算法工程师面试题常常涉及到算法的基础概念和设计方法。算法是解决问题的具体步骤，它必须具备有穷性、确切性、输入、输出和可行性这五个基本特征。在计算机科学中，算法的重要性不言而喻，它们是程序的核心，能够...
算法篇-二叉树
最新发布
分享Java知识，记录思考和感悟
06-21 347
分享二叉树相关概念和算法题
代码随想录算法训练营第38天|● 理论基础 ● 509. 斐波那契数● 70. 爬楼梯 ● 746. 使用最小花费爬楼梯
weixin_74408291的博客
06-17 675
2.确定递推公式dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1]。dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2]。那么dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);3.dp数组初始化由题目可以知道你可以选择从下标为。
【康复学习--LeetCode每日一题】2748. 美丽下标对的数目
Puppet__的博客
06-20 415
如果下标对 i、j 满足 0 ≤ i < j < nums.length ，如果 nums[i] 的 第一个数字 和 nums[j] 的 最后一个数字 互质 ，则认为 nums[i] 和 nums[j] 是一组 美丽下标对。2 和 5 互质，因此 gcd(2,1) == 1。i = 1 和 j = 2 ：nums[1] 的第一个数字是 5 ，nums[2] 的最后一个数字是 1。i = 0 和 j = 1 ：nums[0] 的第一个数字是 1 ，nums[1] 的最后一个数字是 1。
LeetCode 算法：两两交换链表中的节点 c++
小金牛来了
06-20 885
LeetCode 算法：两两交换链表中的节点 c++
2023华数杯C题思路
08-05
对于2023华数杯的C题，我可以给你一些思路。请注意，我并没有访问过真实的2023华数杯题目，所以我只能给你一些常见的C题思路。 通常情况下，C题涉及到算法和数据结构的应用。以下是一些可能的思路： 1. 图论算法：如果题目涉及到图的遍历、最短路径、最小生成树等问题，可以考虑使用图论算法解决。常见的图论算法包括深度优先搜索（DFS）、广度优先搜索（BFS）、Dijkstra算法、Prim算法等。 2. 动态规划：如果题目要求求解最优解或最大值/最小值等问题，可以考虑使用动态规划算法。动态规划通常是将问题分解为子问题，并保存子问题的解，以便在需要时进行查找和使用。 3. 贪心算法：如果题目要求找到局部最优解，并希望通过一系列局部最优解来达到全局最优解，可以考虑使用贪心算法。贪心算法通常是通过每一步选择当前状态下的最优解，而不考虑未来可能出现的情况。 4. 搜索算法：如果题目要求在一个状态空间中找到目标状态，可以考虑使用搜索算法。搜索算法有很多种，如深度优先搜索（DFS）、广度优先搜索（BFS）、A*算法等，选择合适的搜索算法取决于具体的问题。 5. 数学建模：有些题目可能需要将问题转化为数学模型，然后使用数学方法进行求解。这可能涉及到数值计算、方程求解、优化等数学技巧。 请记住，以上只是一些常见的思路，具体问题具体分析。在解决C题时，你可能需要进一步分析题目要求、数据规模、时间复杂度等因素，选择合适的算法进行求解。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

601tyl

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值