最短路练习

最新推荐文章于 2024-07-20 09:51:47 发布
最新推荐文章于 2024-07-20 09:51:47 发布
阅读量66 收藏
点赞数
文章标签： 算法 图论 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yueazero/article/details/132742793
版权

 

目录

A - Til the Cows Come Home
#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
using namespace std;
const int inf=0x3f3f3f3f;
int g[3500][3500];
int dis[3500],vis[3500];
int main()
{
	int t,n;
	cin>>t>>n;
	int a,b,v;
	memset(g,inf,sizeof(g));
	for(int i=1;i<=t;i++)
	{
		cin>>a>>b>>v;
		g[a][b]=g[b][a]=min(g[a][b],v);
	}
	for(int i=1;i<=n;i++)
	{
		dis[i]=g[1][i];
		vis[i]=0;
	}
	dis[1]=0;
	vis[1]=1;
	for(int i=1;i<=n;i++)
	{
		int ans=inf,k=0;
		for(int j=1;j<=n;j++)
		{
			if(dis[j]<ans&&!vis[j])
			{
				ans=dis[j];
				k=j;
			}
		}
		vis[k]=1;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&dis[j]>dis[k]+g[k][j])
			{
				dis[j]=dis[k]+g[k][j];
			}
		}
	}
	cout<<dis[n]<<endl;
}
 B - Frogger

#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#define inf 0x3f3f3f3f;
using namespace std;
double g[3500][3500];
double dis[3500];
int vis[3500];
struct st{
	double x,y;
}s[250];
int main()
{
	int t,n;t=1;
    while(scanf("%d",&n)!=EOF&&n)
    {
	    for(int i=1;i<=n;i++)
	    {
	    	cin>>s[i].x>>s[i].y;
	    	for(int j=1;j<i;j++)
	    	{
	    		double a=s[i].x-s[j].x;
	    		double b=s[i].y-s[j].y;
	    		double v=sqrt(a*a+b*b);
	    	  //  cout<<a<<" "<<b<<" "<<v<<endl;
				g[i][j]=g[j][i]=v;
			
			}
		}
		/*for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				cout<<i<<" "<<j<<" "<<g[i][j]<<endl;
			}
		}*/
	    for(int i=1;i<=n;i++)
	   {
		dis[i]=g[1][i];
		vis[i]=0;
	   }
	for(int i=1;i<=n;i++)
	{
		double ans=inf;
		int k=-1;
		for(int j=1;j<=n;j++)
		{
			if(dis[j]<ans&&!vis[j])
			{
				ans=dis[j];
				k=j;
			}
		}
		if(k!=-1){
		vis[k]=1;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&dis[j]>max(dis[k],g[k][j]))
			{
				dis[j]=max(dis[k],g[k][j]);
			}
		}
	}}
	printf("Scenario #%d\nFrog Distance = %.3lf\n\n",t++,dis[2]);
	
}}
 C - Heavy Transportation
#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
ll g[1500][1500];
ll dis[1500];
int vis[1500];
int main()
{
	int t,n,m;
	cin>>t;
	int e=1;
    while(t--)
    {
    	cin>>n>>m;
    	ll a,b,v;
    	for(int i=1;i<=n;i++)
    	{
    		for(int j=1;j<=n;j++)
    		{
    			if(i==j) g[i][j]=0;
    			else g[i][j]=-1;
			}
		}
	    for(int i=1;i<=m;i++)
	    {
	    	cin>>a>>b>>v;
	    	g[a][b]=g[b][a]=v;
		}
	    for(int i=1;i<=n;i++)
	   {
		dis[i]=g[1][i];
		vis[i]=0;
	   }
	   dis[1]=0;
	   vis[1]=1;
	for(int i=1;i<=n;i++)
	{
		int ans=0;
		int k=-1;
		for(int j=1;j<=n;j++)
		{
			if(dis[j]>ans&&!vis[j])
			{
				ans=dis[j];
				k=j;
			}
		}
		//cout<<k<<endl;
		if(k!=-1){
		vis[k]=1;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&dis[j]<min(dis[k],g[k][j]))
			{
				dis[j]=min(dis[k],g[k][j]);
			}
		}
	}}
	cout<<"Scenario #"<<e<<":"<<endl;
	cout<<dis[n]<<endl<<endl;
	e++;
	
}}
D - Silver Cow Party
#include<bits/stdc++.h>
#define inf 0x7fffffff
//#pragma GCC optimize(2)
using namespace std;
typedef long long ll;
typedef pair<int,int> pa;
inline ll read()
{
    ll x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')
    {
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while(ch>='0' && ch<='9')
        x=x*10+ch-'0',ch=getchar();
    return x*f;
}
struct edg{
	int to;
	int vi,wi;
}e[100005];
int cnt,head[100005];
void add(int a,int b,int c)
{
	e[++cnt].to=head[a];
	e[cnt].vi=b;
	e[cnt].wi=c;
	head[a]=cnt;
}
int dis[100005],vis[100005],vis1[100005],dis1[100005];
struct ed{
	int v,w;
	bool operator<(const ed&c)const
	{
		return c.w<w;
	}
};
priority_queue<ed>q;
int main()
{
  ll n,m,x;
  n=read();
  m=read();
  x=read();
  int a,b,t;
  for(int i=0;i<m;i++)
  {
  	a=read();
  	b=read();
  	t=read();
  	add(a,b,t);
  }
  memset(vis,0,sizeof(vis));
  memset(dis,0x3f,sizeof(dis));
  q.push(ed{x,0});
  vis[x]=1;
  dis[x]=0;
  while(!q.empty())
  {
  	ed d=q.top();
  	q.pop();
  	vis[d.v]=0;
  	int a1=d.v,b1=d.w;
  	for(int i=head[a1];i;i=e[i].to)
  	{
  		int j=e[i].vi;
  		if(dis[j]>dis[a1]+e[i].wi)
  		{
  			dis[j]=dis[a1]+e[i].wi;
  			if(!vis[j])
  			{
  				vis[j]=1;
  				q.push(ed{j,dis[j]});
			}
		}
	}
  }
  int ans=0,su=0;
  for(int i=1;i<=n;i++)
  {
  	if(i!=x)
  	{
  		su=dis[i];
  		//cout<<dis[i]<<endl;
  		priority_queue<ed>p;
  		memset(vis1,0,sizeof(vis1));
  		memset(dis1,0x3f,sizeof(dis1));
  		p.push(ed{i,0});
  		dis1[i]=0;
  		vis1[i]=1;
  		while(!p.empty())
  		{
  			int l=p.top().v;
  			int y=p.top().w;
  			p.pop();
  			vis1[l]=0;
  			for(int i=head[l];i;i=e[i].to)
  			{
  				int k=e[i].vi;
  				if(dis1[k]>dis1[l]+e[i].wi)
  				{
  					dis1[k]=dis1[l]+e[i].wi;
  					if(!vis1[k])
  					{
  						vis1[k]=1;
  						p.push(ed{k,dis1[k]});
					  }
				  }
			  }
		}
		su+=dis1[x];
		if(su>ans) ans=su;
	}
  }
  cout<<ans<<endl;
}
F - Wormholes
#include<bits/stdc++.h>
#define inf 0x7fffffff
//#pragma GCC optimize(2)
using namespace std;
typedef long long ll;
typedef pair<int,int> pa;
inline ll read()
{
    ll x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')
    {
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while(ch>='0' && ch<='9')
        x=x*10+ch-'0',ch=getchar();
    return x*f;
}
struct edg{
	int to;
	int vi,wi;
}e[100005];
int cnt,head[100005];
void add(int a,int b,int c)
{
	e[++cnt].to=head[a];
	e[cnt].vi=b;
	e[cnt].wi=c;
	head[a]=cnt;
}
int dis[100005],vis[100005],cn[100005],dis1[100005];
struct ed{
	int v,w;
	bool operator<(const ed&c)const
	{
		return c.w<w;
	}
};
priority_queue<ed>q;
int main()
{
  int t;
  t=read();
  while(t--)
  {
  	ll n,m,w;
  	n=read();
  	m=read();
  	w=read();
  	int u,v,p;
	  queue<int>q;	
	memset(vis,0,sizeof(vis));
	memset(dis,0,sizeof(dis));
	memset(cn,0,sizeof(cn));
	memset(head,0,sizeof(head));
	cnt=0;
  	for(int i=1;i<=n;i++)
  	{
  		q.push(i);
  		vis[i]=1;
	}
  	for(int i=0;i<m;i++)
  	{
  		u=read();
  		v=read();
  		p=read();
  		add(u,v,p);
  		add(v,u,p);
	}
	for(int i=0;i<w;i++)
	{
		u=read();
		v=read();
		p=read();
		add(u,v,-p);
	}

	int fl=0;
	while(!q.empty())
	{
		int f=q.front();
		q.pop();
		vis[f]=0;
		for(int i=head[f];i;i=e[i].to)
		{
			int v=e[i].vi;
			if(dis[v]>dis[f]+e[i].wi)
			{
				dis[v]=dis[f]+e[i].wi;
				cn[v]=cn[f]+1;
				if(cn[v]>=n)
				{
					fl=1;
					break;
				}
				if(!vis[v])
				{
					q.push(v);
					vis[v]=1;
				}
			}
			
		}if(fl) break;
	}
	if(fl) cout<<"YES"<<endl;
	else cout<<"NO"<<endl;
	for(int i=0;i<=n;i++)
	{
		e[i].to=0;
		e[i].vi=0;
		e[i].wi=0;
	}
  }
}
G - MPI Maelstrom
//#include<bits/stdc++.h>
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include<stdio.h>
#define inf 0x3fffffff
//#pragma GCC optimize(2)
using namespace std;
typedef long long ll;
ll ma=1e18;
inline ll read()
{
    ll x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')
    {
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while(ch>='0' && ch<='9')
        x=x*10+ch-'0',ch=getchar();
    return x*f;
}
struct ed{
	int v,w,to;
}e[100005];
int head[100005],vis[100005],dis[100005],cnt;
void add(int x,int y,int z)
{
	e[++cnt].to=head[x];
	e[cnt].v=y;
	e[cnt].w=z;
	head[x]=cnt;
}
struct qq{
	int b,c;
	bool operator<(const qq& zz)const
	{
		return c>zz.c;
	}
};
int t[10005][10005];
int main()
{
  int n;
  while(cin>>n){
  memset(vis,0,sizeof(vis));
  //memset(head,0,sizeof(head));
 // cnt=0;
 for(int i=1;i<=n;i++)
 {
 	for(int j=1;j<=i;j++)
 	{
 		if(j!=i) t[i][j]=t[j][i]=inf;
 		else t[i][j]=0;
	 }
 }
  
  for(int i=2;i<=n;i++)
  {
  	for(int j=1;j<i;j++)
  	{
	    char a[30];
  		scanf("%s",a);
  		if(a[0]!='x')
  		{
  			int l=atoi(a);
  			t[i][j]=t[j][i]=l;
		}
	  }
  }
  for(int i=1;i<=n;i++)
  dis[i]=t[1][i];
  dis[1]=0;
  vis[1]=1;
  int w=inf,k=0;
  for(int i=1;i<=n;i++)
  {
  	w=inf,k=0;
  	for(int j=1;j<=n;j++)
  	{
  		if(!vis[j]&&dis[j]<w)
  		{
  			w=dis[j];
  			k=j;
		  }
	  }
	  vis[k]=1;
	  for(int j=1;j<=n;j++)
	  {
	  	if(!vis[j]&&dis[j]>dis[k]+t[k][j])
	  	{
	  		dis[j]=dis[k]+t[k][j];
		  }
	  }
  }
  ll ans=0;
  for(int i=2;i<=n;i++)
  {
  	if(dis[i]>ans&&dis[i]!=inf)
  	ans=dis[i];
  //	cout<<dis[i]<<endl;
  }
  cout<<ans<<endl;
 
  }
}
H-Cow Contest
#include<bits/stdc++.h>
#define inf 0x7fffffff
//#pragma GCC optimize(2)
using namespace std;
typedef long long ll;
inline ll read()
{
    ll x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')
    {
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while(ch>='0' && ch<='9')
        x=x*10+ch-'0',ch=getchar();
    return x*f;
}

/*struct edge{
	int vi,wi,nex;
}e[510];
struct node{
	int x,y;
	bool operator <(const node&a)const
	{
		return y>a.y;
	}
};
void add(int x,int y,int w)
{
	e[++cnt].nex=head[x];
	e[cnt].vi=y;
	e[cnt].wi=w;
	head[x]=cnt;
}
priority_queue<node>q;*/
int g[150][150];
int main()
{
	//int n,m;
	ll k;
	int n;
	n=read();
	//ans[0]=1;
	k=read();
	//map<ll,ll>p,q,r;
	ll x,y;
	for(int i=0;i<k;i++)
	{
		x=read();
		y=read();
		g[x][y]++;
	}
	//ll ans=1,a;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			for(int k=1;k<=n;k++)
			{
				if(g[j][i]&&g[i][k])
				{
					g[j][k]++;
				}
			}
		}
	}
	int f=0,ans=0;
	for(int i=1;i<=n;i++)
	{
		f=0;
		for(int j=1;j<=n;j++)
		{
			if(g[j][i]||g[i][j]||i==j)
			{
				continue;
			}
			else {
				f=1;
				break;
			}
		}
		if(!f) ans++;
	}
	cout<<ans<<endl;
	
}
I - Arbitrage
#include<bits/stdc++.h>
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include<stdio.h>
#define inf 0x3fffffff
//#pragma GCC optimize(2)
using namespace std;
typedef long long ll;
ll ma=1e18;
inline ll read()
{
    ll x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')
    {
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while(ch>='0' && ch<='9')
        x=x*10+ch-'0',ch=getchar();
    return x*f;
}
int main()
{
   int n,k=1;
   while(1){
   n=read();
   if(n==0) break;
   string a,b;
   double g[50][50];
   for(int i=1;i<=n;i++)
   {
   	for(int j=1;j<=n;j++)
   	{
   		if(i==j) g[i][j]=1.0;
   		else g[i][j]=0;
	   }
   }
   map<string,int>p;
   for(int i=1;i<=n;i++)
   {
   	 cin>>a;
   	 p[a]=i;
   }
   int t;
   double c;
   t=read();
   for(int i=0;i<t;i++)
   {
   	 cin>>a>>c>>b;
   	 int l=p[a],m=p[b];
   	 g[l][m]=c;
   }
   cout<<"Case "<<k<<": ";
   k++;
   for(int i=1;i<=n;i++)
   {
   	for(int j=1;j<=n;j++)
   	{
   		for(int d=1;d<=n;d++)
   		{
   			if(g[j][d]<g[j][i]*g[i][d])
   			{
   				g[j][d]=g[j][i]*g[i][d];
			   }
		   }
	   }
   }
   int fl=0;
   for(int i=1;i<=n;i++)
   {
   	 if(g[i][i]>1)
   	 {
   	 	fl=1;
   	 	break;
		}
   }
   if(fl) cout<<"Yes"<<endl;
   else cout<<"No"<<endl;
}}
J - Invitation Cards
#include<bits/stdc++.h>
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include<stdio.h>
#define inf 0x3fffffff
//#pragma GCC optimize(2)
using namespace std;
typedef long long ll;
ll ma=1e18;
inline ll read()
{
    ll x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')
    {
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while(ch>='0' && ch<='9')
        x=x*10+ch-'0',ch=getchar();
    return x*f;
}
struct edg{
	ll to,v,w;
}e[1000005];
int cnt,head[1000005],cnt1,vis[1000005],t[1000005][3];
ll dis[1000005];
void add(ll x,ll y,ll z)
{
	e[++cnt].to=head[x];
	e[cnt].v=y;
	e[cnt].w=z;
	head[x]=cnt;
}
queue<int>o;
int main()
{
	int n;
	n=read();
	while(n--)
	{
		ll p,q;
		p=read();
		q=read();
		memset(head,0,sizeof(head));
		//memset(head1,0,sizeof(head1));
		cnt=0;
		memset(vis,0,sizeof(vis));
		memset(dis,0x3f,sizeof(dis));
		for(int i=0;i<q;i++)
		{
			t[i][0]=read();
			t[i][1]=read();
			t[i][2]=read();
			add(t[i][0],t[i][1],t[i][2]);
		//	add1(b,a,c);
		}
	//	queue<int>o,f;
		o.push(1);
		vis[1]=1;
		dis[1]=0;
		while(!o.empty())
		{
			int s=o.front();
			o.pop();
			vis[s]=0;
			for(int i=head[s];i;i=e[i].to)
			{
				int vi=e[i].v;
				if(dis[vi]>dis[s]+e[i].w)
				{
					dis[vi]=dis[s]+e[i].w;
					if(!vis[vi])
					{
						vis[vi]=1;
						o.push(vi);
					}
				}
			}
		}
		ll ans=0;
		for(int i=1;i<=p;i++)
		{
			ans+=dis[i];
			dis[i]=inf;
		}
		memset(head,0,sizeof(head));
		//memset(head1,0,sizeof(head1));
		cnt=0;
		memset(vis,0,sizeof(vis));
		memset(e,0,sizeof(e));
		for(int i=0;i<q;i++)
		{
			add(t[i][1],t[i][0],t[i][2]);
		//	add1(b,a,c);
		}
		o.push(1);
		vis[1]=1;
		dis[1]=0;
		while(!o.empty())
		{
			int s=o.front();
			o.pop();
			vis[s]=0;
			for(int i=head[s];i;i=e[i].to)
			{
				int vi=e[i].v;
				if(dis[vi]>dis[s]+e[i].w)
				{
					dis[vi]=dis[s]+e[i].w;
					if(!vis[vi])
					{
						vis[vi]=1;
						o.push(vi);
					}
				}
			}
		}
		for(int i=2;i<=p;i++)
		{
			ans+=dis[i];
		}	
		memset(e,0,sizeof(e));
			cout<<ans<<endl;
	}
}

K - Candies

yueazero
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
acm训练专题四：最短路练习
软糖汽水
04-10 958
专题训练四：最短路练习
[kuangbin带你飞]专题四 最短路练习
qq_43235540的博客
01-18 210
[kuangbin带你飞]专题四 最短路练习 专题链接 推荐关于图论的刷题 A - Til the Cows Come Home poj-2387 题意： 有n个点，t条路，给出每条路的长度，问怎么走能使得从起点走到终点路路程最短。 难度： 2颗星，单源最短路径，dijkstra模板 题解： 两种解法见此 B - Frogger poj-2253 题意： 给n个点的坐标，问如何走使得最长边最短。 也就是给了点图，找最小生成树的最大边。 C - Heavy Transportation poj-1797 题意
[kuangbin带你飞] 专题四 最短路练习 练习
CCCCTong的博客
04-23 231
1、Til the Cows Come Home 裸的最短路，wa一路发现自己T，N读入反了，据说还有重边，不过是邻接矩阵需要考虑的问题，前向星和邻接表可以忽略。 #include <iostream> #include <algorithm> #include <cstdio> #include <queue> #include <c...
P5651 基础最短路练习题
b_b_lai_lai的博客
06-09 145
P5651 基础最短路练习题 题目链接 #include <bits/stdc++.h> #define For(i, j, k) for (int i = (int)(j); i <= (int)(k); i++) #define Rep(i, j, k) for (int i = (int)(j); i >= (int)(k); i--) #define ll long long using namespace std; const int N = 100005; struc
P5651 基础最短路练习题（bfs + 思维）
lucifer1214的博客
07-13 283
P5651 基础最短路练习题 思路： 题目中给出定义一条简单路径的权值为路径上所有边边权的异或和，那么我们首先要得出一个结论 xxx xorxorxor xxx === 000 也就是说，我们再求路径权值时假设有a1a_1a1​a2a_2a2​a3a_3a3​a4a_4a4​a5a_5a5​a6a_6a6​和边w1w_1w1​w2w_2w2​w3w_3w3​w4w_4w4​w5w_5w5​ 举个例子a1a_1a1​到a4a_4a4​点和到a6a_6a6​距离就是 圈起来的就是异或… 所以a4a _4a
最短路.zip
12-04
标题“最短路.zip”和描述“蓝桥杯VIP题和题解”暗示了这个压缩包包含的是关于解决计算最短路径问题的编程题目和解答。蓝桥杯是一场知名的程序设计竞赛，其中涉及了大量的算法挑战，特别是对于图论和算法优化的运用...
最短路算法模板 最短路算法模板
01-25
最短路算法是图论中的一个核心问题，它在计算机科学和网络优化中有着广泛的应用。ACM（国际大学生程序设计竞赛）中，最短路算法是常见的考察点，因此掌握其模板对于参赛者至关重要。这里我们将深入探讨几种常见的最...
电学中短路练习题.doc
10-08
综上所述，这些练习题涵盖了电路的基本概念、电路连接方式、电流方向、短路现象、电路元件的工作状态、电路安全以及电路图的解读等多个核心知识点。通过解决这些问题，学生可以提升对电学基础知识的理解和应用能力。
电路短路断路专项练习.doc
12-17
这些题目涉及的是电路基础知识，特别是关于电路中的短路和断路问题。短路是指电流不按预期路径通过，而是直接从电源正极流向负极，通常会导致电流过大，可能损坏设备或引发火灾。断路则是指电路中的某个部分断开，...
最短路_matlab图论_
09-29
在压缩包文件名"最短路"中，我们可以推测这可能包含了一系列与最短路径相关的MATLAB代码示例、练习题或测试案例。这些资源可能涵盖了如何读取图数据、构建邻接矩阵、实现Floyd-Warshall算法以及可视化结果等内容。 ...
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 241
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
插入和选择排序
c23856的博客
07-20 227
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 220
完全二叉树的节点个数-递归
python实现图像缩放算法
最新发布
qq_42568323的博客
07-20 262
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
拆分整数 java
laocooon的博客
07-16 680
输入: n = 10输出: 36解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。输入: n = 2输出: 1解释: 2 = 1 + 1, 1 × 1 = 1。），并使这些整数的乘积最大化。你可以获得的最大乘积。
算法力扣刷题记录 五十【106.从中序与后序遍历序列构造二叉树】和【105.从前序与中序遍历序列构造二叉树】
danaaaa的博客
07-17 1069
构造二叉树
前缀和算法——部分OJ题详解
aaqq800520的博客
07-17 979
（文章的题目解释可能存在一些问题，欢迎各位小伙伴私信或评论指点（双手合十））
面试题 27. 二叉树的镜像
weixin_51332735的博客
07-16 476
请完成一个函数，输入一个二叉树，该函数输出它的镜像。
《算法笔记》总结No.8——双指针
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-17 1047
去年发表过较简单的双指针案例，建议先行阅读~C++实现双指针算法_c++ 双指针排序-CSDN博客文章浏览阅读154次。本贴介绍双指针的入门典例~_c++ 双指针排序https://jslhyh32.blog.csdn.net/article/details/129829790相比说双指针是一种算法，他更倾向是一种编程技巧，话不多说直接看一个引例：如下，给定递增序列【1,3,5,7,9】，寻找到两个相加为16的元素。如果使用暴力的思想，相当于是一个双层循环：外层下标i对应的A[i]和内层下标为j的A[j]之
电力系统分析练习题详解
6. 变压器参数计算：变压器的参数如电抗XT、电纳GT、电阻RT可以通过特定的试验数据来确定，例如空载损耗、短路电流、短路电压百分比等。 7. 阻抗基准值和电压基准值：在电力系统分析中，阻抗基准值是基于三相功率Sb...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值