一本通 MST

最新推荐文章于 2024-11-05 21:58:11 发布
最新推荐文章于 2024-11-05 21:58:11 发布
阅读量251 收藏 2
点赞数 3
分类专栏： 图论 一本通提高版 文章标签： leetcode c++ 学习 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60921016/article/details/136958813
版权

黑暗城堡

类似最短路计数的问题，模拟prim的计数过程就好了，可以写成nlog

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 1e3+10;
const int inf = 0x3f3f3f3f;
const int mod = 2147483647;
const int M = 1e6+10;
int n,m;
int id[N];
int e[M],ne[M],w[M],h[N],idx;
void add(int a,int b,int c){
	e[idx] = b,ne[idx] = h[a],w[idx] = c,h[a] = idx++;
}
int cost[1010][1010];
int dist[1010];
bool vis[1010];


void spfa()
{
	queue<int>q;
	memset(dist,0x3f,sizeof dist);
	vis[1] = true;
	dist[1] = 0;
	q.push(1);
	
	while(q.size()){
		auto ver = q.front();
		//cout<<ver<<"\n";
		q.pop();
		vis[ver] = false; 
		for(int i=h[ver];~i;i=ne[i]){
			int j = e[i];
			
			if(dist[j]>dist[ver]+w[i]){
				dist[j] = dist[ver] + w[i];
				if(!vis[j]){
					q.push(j);
					vis[j] = true;
				}
			}
		}
	}
	
	
}
 
bool cmp(int a,int b){
	return dist[a]<dist[b];
}

void solve()
{
	scanf("%lld%lld",&n,&m);
	for(int i=1;i<=n;i++)
	 for(int j=1;j<=n;j++)
	  if(i==j)cost[i][j] = 0;else cost[i][j] = cost[j][i] = inf;
	
	memset(h,-1,sizeof h);
		  
	for(int i=1;i<=m;i++){
		int a,b,c;scanf("%lld%lld%lld",&a,&b,&c);
		if(c<cost[a][b])cost[a][b] = cost[b][a] = c;
		add(a,b,c);
		add(b,a,c);
	}	
	
	spfa();
	

	
	for(int i=1;i<=n;i++)id[i] = i;
	
	sort(id+1,id+1+n,cmp);
	
	int res = 1;
	
	for(int i=2;i<=n;i++){
		int cnt = 0;
		for(int j=1;j<i;++j){
			if(dist[id[i]]==dist[id[j]]+cost[id[j]][id[i]])cnt++;
		}
		cnt%=mod;
		if(cnt)res = (res*cnt)%mod;
	}
	
	cout<<res;
	
	

}

signed main()
{
	//ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 1e3+10;
const int inf = 0x3f3f3f3f;
const int mod = 2147483647;
const int M = 1e6+10;
int n,m;
int e[M],ne[M],w[M],h[N],idx;
int dp[N];


void add(int a,int b,int c){
	e[idx] = b,ne[idx] = h[a],w[idx] = c,h[a] = idx++;
}
int dist[1010];
bool vis[1010];



void dijkstra(int num)
{
	priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>heap;
	if(!num)memset(dist,0x3f,sizeof dist);
	memset(vis,0,sizeof vis);
	dist[1] = 0;
	
	dp[1] = 1;//计数数组
	heap.push({0,1});
	
	while(heap.size()){
		auto t = heap.top();
		heap.pop();
		

		
		int distance = t.first,ver = t.second;
		if(vis[ver])continue;
		vis[ver] = true;
		
		for(int i=h[ver];~i;i=ne[i]){
			int j = e[i];
			if(dist[j]>=w[i]+distance){
				if(num)dp[j] ++; 
				dist[j] = dist[ver]+w[i];
				heap.push({dist[j],j});
			}
		}
		
	}
	

}



bool cmp(int a,int b){
	return dist[a]<dist[b];
}

void solve()
{
	scanf("%lld%lld",&n,&m);


	memset(h,-1,sizeof h);
		  
	for(int i=1;i<=m;i++){
		int a,b,c;scanf("%lld%lld%lld",&a,&b,&c);
		add(a,b,c);
		add(b,a,c);
	}	
	
	dijkstra(0);
	dijkstra(1);
	
	//for(int i=1;i<=n;i++)cout<<dist[i]<<" ";
	//cout<<"\n";
	
	int res = 1;
	for(int i=1;i<=n;i++)res = res*dp[i]%mod;
	cout<<res;
	

	
	

	

}

signed main()
{
	//ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

新的开始

虚拟原点 + prim跑最小生成树

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 1e5+10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9+7;

int n,q;


int g[1010][1010];
bool vis[N];
int dist[N];
int ans = 0;
void prim()
{
	
	memset(dist,0x3f,sizeof dist);
	dist[0] = 0;
	
	for(int i=0;i<=n;i++){
		int t = inf;
		int k;
		for(int j=0;j<=n;j++){
			if(dist[j]<t&&!vis[j]){
				t = dist[j],k = j;
			}
		}
		
		//cout<<k<<" "<<t<<"gaga\n";;
		
		ans+=t;
		vis[k] = true;
		
		for(int j=1;j<=n;j++)dist[j] = min(dist[j],g[k][j]);
		
	}
	
	
}

void solve()
{
	cin>>n;
	
	for(int i=1;i<=n;i++){
		int x;cin>>x;
		g[0][i] = x;
	}	
	
	
	for(int i=1;i<=n;i++)
	 for(int j=1;j<=n;j++)
	  cin>>g[i][j];
	  
	prim();
	
	cout<<ans;

}

signed main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

北极通讯网络

书上给的是一个证明的结论 数据范围很小可以直接暴力乱搞

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 1e5+10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9+7;

int n,k;
int p[N];
int find(int x){
	
	if(x!=p[x])p[x] = find(p[x]);
	return p[x];
}


struct Node{
	int x,y;
}node[N];


double get_dist(int a,int b){
	int dx = node[a].x - node[b].x;
	int dy = node[a].y - node[b].y;
	return sqrt(dx*dx+dy*dy);	
}

bool check(double mid){
	
	
	for(int i=1;i<=n;i++)p[i] = i;
	
	for(int i=1;i<=n;i++)
	  for(int j=1;j<=n;j++){
	  	if(i==j)continue;
	  	double x = get_dist(i,j);
	  	if(x<=mid){
	  		int a = find(i),b = find(j);
	  		p[a] = b;
	  	}
	  }
	  
	set<int>s;
	for(int i=1;i<=n;i++)s.insert(find(i));
	return s.size()<=k;
	  
	
}

void solve()
{
	cin>>n>>k;
	for(int i=1;i<=n;i++)cin>>node[i].x>>node[i].y;
	
	
	
	double l = 0,r = 1e4;
	
	while(r-l>1e-4){
		double mid = (l+r)/2;
		if(check(mid))r = mid;
		else l = mid;
		//cnt++;
		//cout<<l<<" "<<r<<"\n";
		//if(cnt>=50)break;
	}
	
	printf("%.2lf",r);
	
	

}

signed main()
{
	//ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

构造完全图

考虑Kruskal的过程，它每次对两个集合进行操作，每次都是只保留最短的那条边，因此每次操作两个集合的时候我们考虑集合里面的其他边对答案的贡献就好 然后乘法原理一下就可以得到答案了

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 1e5+10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9+7;

int n,q;
struct Node{
	int a,b,w;
	bool operator<(const Node&W)const{
		return w<W.w;
	}
}node[N];

int p[N],sz[N];


int find(int x){
	if(x!=p[x])p[x] = find(p[x]);
	return p[x];
}

void solve()
{
	
	cin>>n;
	int res = 0;
	for(int i=1;i<n;i++){
		int a,b,c;cin>>a>>b>>c;
		node[i] = {a,b,c};
		res+=c;
	}
	
	
	
	sort(node+1,node+n);
	for(int i=1;i<=n;i++)p[i] = i,sz[i] = 1;
	
	for(int i=1;i<n;i++){
		
		
		int a = node[i].a,b = node[i].b,c = node[i].w;
		a = find(a),b = find(b);
		
		res = res + (sz[a]*sz[b]-1)*(c+1);
		
		p[a] = b;
		sz[b]+=sz[a];
	}
	
	cout<<res;
	
	

}

signed main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

秘密的奶牛运输

暴力求进行严格次小生成树

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 510,M = 2e5+10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9+7;

int n,m;
int e[M],ne[M],w[M],h[N],idx;
int dist1[N][N];
int dist2[N][N];
void add(int a,int b,int c){
	e[idx] = b,ne[idx] = h[a],w[idx] = c,h[a] = idx++;
}
struct Node{
	int a,b,w,f;
	bool operator<(const Node&W)const{
		return w<W.w;
	}
}node[M];
int p[N];
int sum;
int find(int x){
	if(x!=p[x]) p[x] = find(p[x]);
	return p[x];
}


void dfs(int u, int fa, int maxd1, int maxd2, int d1[], int d2[])
{
    d1[u] = maxd1, d2[u] = maxd2;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j != fa)
        {
            int td1 = maxd1, td2 = maxd2;
            if (w[i] > td1) td2 = td1, td1 = w[i];
            else if (w[i] < td1 && w[i] > td2) td2 = w[i];
            dfs(j, u, td1, td2, d1, d2);
        }
    }
}
void solve()
{
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		cin>>node[i].a>>node[i].b>>node[i].w;
	}
	
	
	sort(node+1,node+1+m);
	
	for(int i=1;i<=n;i++)p[i] = i;
	memset(h,-1,sizeof h);
	for(int i=1;i<=m;i++){
		int a = node[i].a,b = node[i].b,c = node[i].w;
		int pa = find(a),pb = find(b);
		if(pa==pb)continue;
		node[i].f = 1;
		add(a,b,c),add(b,a,c);
		sum+=c;
		p[pa] = pb; 
	}
	
	
	
	for(int i=1;i<=n;i++)dfs(i,-1,-inf,-inf,dist1[i],dist2[i]);
	
	
	
	int res=1e15;
	for(int i=1;i<=m;i++){
		if(node[i].f)continue;
		int t = inf;
		int a = node[i].a,b = node[i].b,c = node[i].w;
		if(c>dist1[a][b])t = sum+c-dist1[a][b]; 
		else if(c>dist2[a][b])t = sum+c-dist2[a][b];
		
		res = min(res,t);
	}
	
	cout<<res;

}

signed main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

Tree

一开始想到的是直接贪心的加能加上的最小的几条白边，其实不是最优的

这里有个经典的套路我之前没怎么接触过就是 带权二分答案，当你求某个东西出现的次数恰好是k的时候让你最优化问题，你可以直接做，通过给这个东西一个权值让它的出现次数呈现单调性也就可以二分答案来求了

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 1e5+10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9+7;

int n,m,k;


struct Node{
	int a,b,w,c;
	bool operator<(const Node&W)const{
		if(W.w!=w)return w<W.w;
		return c<W.c;
	}
}node[N];
int p[N];

int s;

int find(int x){
	if(x!=p[x])p[x] = find(p[x]);
	return p[x];
}

int check(int mid){
	for(int i=0;i<=n;i++)p[i] = i;
	s = 0;
	for(int i=1;i<=m;i++)if(node[i].c==0)node[i].w-=mid;
	sort(node+1,node+1+m);
	int cnt = 0;
	for(int i=1;i<=m;i++){
		int a = find(node[i].a),b = find(node[i].b);
		if(a==b)continue;
		p[a] = b;
		s+=node[i].w;
		if(!node[i].c)cnt++;
		
	}
	
	for(int i=1;i<=m;i++)if(node[i].c==0)node[i].w+=mid;
	//cout<<cnt<<"\n";
	return cnt;
	
	
	
}
void solve()
{
	//你想控制答案中某个东西的恰好的出现次数
	//可以使用带权二分答案
	cin>>n>>m>>k;
	
	for(int i=1;i<=m;i++){
		int a,b,w,c;cin>>a>>b>>w>>c;
		node[i] = {a,b,w,c};
	}
	
	int l = -1e5,r = 1e5;
	while(l+1!=r){
		int mid = (l+r)/2;
		if(check(mid)>=k)r = mid;
		else l = mid;
		//cout<<l<<" "<<r<<"\n";
	}
	
	check(r);
	cout<<s+k*r<<"\n";
	
	
	

}

signed main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

最小生成树计数

调了一下午 不知道自己死在哪里了，发现这道题并查集不能用按秩合并，因为要dfs恢复现场

恶心坏了.......太菜了 吃一堑长一智吧～～

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5+10;
const int inf = 0x3f3f3f3f;
const int mod = 31011;

using namespace std;
int n,m;

struct Edge{
	int x,y,w;
	bool operator<(const Edge&W)const{
		return w<W.w;
	}
}edge[N];
int father[N];


struct Node{
	int l,r;
	int cnt;
}a[N];
int tot;
int sum;

int Find(int x){
	if(x!=father[x])return Find(father[x]);
	return father[x];
}


int Kruskal()
{
	for(int i=1;i<=n;i++)father[i] = i;
	
	sort(edge+1,edge+1+m);
	int cnt = 0;
	
	for(int i=1;i<=m;i++){
		if(edge[i].w!=edge[i-1].w){
			tot++;
			a[tot].l = i;
			a[tot-1].r = i-1;
		}
		
		int x = edge[i].x,y = edge[i].y;
		x = Find(x),y = Find(y);
		if(x==y)continue;
		
		father[x] = y;
		
		cnt++;
		a[tot].cnt++;
		
	}
	
	
	a[tot].r = m;
	
	
	return cnt;
}

void dfs(int x,int now,int s){
	
	
	if(now>a[x].r){
		//cout<<s<<"??\n";
		if(s==a[x].cnt)sum++;
		return;
	}
	
	int fx = Find(edge[now].x),fy = Find(edge[now].y);
	//cout<<fx<<" "<<fy<<"\n";
	if(fx!=fy){
		father[fx] = fy;
		dfs(x,now+1,s+1);
		father[fx] = fx;
		father[fy] = fy;
	}
	
	
	dfs(x,now+1,s);
}


void solve()
{
	cin>>n>>m;
	for(int i=1;i<=m;i++)
		cin>>edge[i].x>>edge[i].y>>edge[i].w;
	
	
	int num = Kruskal();
	
	if(num!=n-1){cout<<0;return;}
	

	
	int res = 1;
	for(int i=1;i<=n;i++)father[i] = i;
	
	for(int i=1;i<=tot;++i){
		sum = 0;
		
		dfs(i,a[i].l,0);
		//cout<<"??"<<"\n";
		//cout<<sum<<"\n";
		res = res*sum%mod;
		
		
		for(int j = a[i].l;j<=a[i].r;++j){
			int fx = Find(edge[j].x);
			int fy = Find(edge[j].y);
			if(fx!=fy)father[fx] = fy;
		}
	}
	

	
	
	cout<<res;

}

signed main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

灬德布罗意的猫灬
关注
专栏目录
信息学奥赛一本通 1143：最长最短单词
超级氯化钾的博客
06-02 2710
  1143：最长最短单词 时间限制: 1000 ms         内存限制: 65536 KB 提交数: 2327     通过数: 703  【题目描述】  输入1行句子(不多于200个单词，每个单词长度不超过100)，只包含字母、空格和逗号。单词由至少一个连续的字母构成，空格和逗号都是单词间的间隔。  试输出第1个最长的单词和第1个最短单词。 【输入】 一行句子。 【...
libreoj 10069 「一本通 3.1 练习 4」Tree 题解
LightningUZ的博客
03-15 440
博客观赏效果更佳 题意简述 一个图有 nnn 个点 mmm 条边，每个边是白色或黑色。生成一棵树使得白边的数量恰好是 kkk，并且边权和最小。输出最小的边权和。 1≤n,m≤1051\le n,m\le 10^51≤n,m≤105，边权在 [1,100][1,100][1,100] 之间 思路 我们在跑朴素的 Kruskal 的时候，把每个白边都调的贵一点，或者便宜一点。把白边弄便宜的时候，就会多...
最小生成树（MST）
来啦(#^.^#)
11-28 750
目录 一、知识点 二、最小生成树计数 三、例题 一、知识点 1. 生成树定义：在一个有n个点的无向连通图中，取其n-1条边并连接所有的顶点，所得到的子图称为原图的一棵生成树。 2. 树的属性：无环+连通+任意两点之间只有唯一的简单路径+删掉任意边就不连通 3. 最小生成树：各边权和最小的一棵生成树。 4. 最小边原则：图中权值最小的边（如果唯一的话）一定在最小生成树上 5. 唯一...
次小生成树（有无重边）
来啦(#^.^#)
12-06 279
一切都从这道题开始.... #10068. 「一本通 3.1 练习 3」秘密的牛奶运输 嗯，然后我去看了次小生成树，踉踉跄跄地做了好久奇奇怪怪的就A了... 然后！突然发现题上说是有重边的！然后我！开始质疑我的代码！一直改呀想呀陷入了怪圈....  对，怪圈....  用Kruskal做本来就是存边的，哪里还用考虑重不重边的问题呀！大概还是自己太蠢了吧... (つД｀)･ﾟ･ 首先，什么是次小...
【MST】最小生成树prim 算法原理及实现
Z_sea的博客
05-10 1357
以下参考《信息学竞赛一本通 提高篇》 前置知识点： 1、生成树： 在一个|V| 个点的无向联通图中，取其中|V|-1条边，并链接所有的顶点，所得到的子图称为原图的一颗生成树。 2、树的属性: 树是图的一种特殊形态。图G是树当且仅当一下任意一个条件成立 1、G有|V|-1条边，无环。 2、G有|V|-1条边，连通。 3、任意两点之间只有唯一的简单路径 4、G连通，但任意删除一条边后...
洛谷 P1991 无线通讯网/一本通OJ 1487【例 2】北极通讯网络
weixin_30832405的博客
09-08 766
要求用尽可能小的代价使图联通，考虑最小生成树。如果不断加边，将分散的点连结为\(p-s\)个联通块，则\(s\)个无线电站可以分布在每个联通块中的任意点。 而此处要求的半径D是对于所有点的覆盖半径，相当于最小瓶颈生成树。使用kruskal连边，答案就是连的\(p-s\)条边中最长的一条。 代码 #include<iostream> #include<cstdio>...
一本通1555【例 4】次小生成树
weixin_30367945的博客
02-05 342
1555：【例 4】次小生成树 时间限制: 1000 ms 内存限制: 524288 KB 题目描述 原题来自：BeiJing 2010 组队赛 给定一张N个点M条边的无向图，求无向图的严格次小生成树。 设最小生成树的边权之和为sum，严格次小生成树就是指边权之和大于sum的生成树中最小的一个。 输入格式 ...
1393：联络员(liaison)
qq_42552468的博客
06-27 952
#include<iostream> #include<cstdio> #include<algorithm> using namespace std; struct node { int x,y,v,flag; }; node a[10009]; int f[10009]; int findx(int i) { if(f[i]!=i)f[i]=...
HDU题目分类
jinjiahao5299的专栏
03-24 562
hdu题目分类 模拟题, 枚举 1002 1004 1013 1015 1017 1020 1022 1029 1031 1033 1034 1035 1036 1037 1039 1042 1047 1048 1049 1050 1057 1062 1063 1064 1070 1073 1075 1082 1083 1084 1088 1106 1107 1113 1117 111
MST706-Master_MST706_MST706Datasheet_
10-02
《MST706处理器：小型LCD电视的中枢大脑》 在现代电子设备中，处理器是心脏般的存在，驱动着各种复杂功能的运行。对于小型LCD电视而言，MST706处理器是一款至关重要的组件，它以其高效能、低功耗和小巧的尺寸，为...
MST705 MST703晨星驱动芯片Keil完整工程
01-19
标题"MST705 MST703晨星驱动芯片Keil完整工程"指的是一个基于Keil集成开发环境的工程项目，该工程是针对MST705和MST703这两款晨星（Morning Star）品牌的驱动芯片设计的。晨星半导体是一家专注于LCD驱动芯片的公司，...
mst.rar_matlab MST_mst_mst matlab_mst的Matlab实现
09-20
"mst.rar_matlab MST_mst_mst matlab_mst的Matlab实现" 这个标题提到了"MST"，全称为Minimum Spanning Tree（最小生成树），这是一种在图论中的算法，用于寻找连接所有节点的边的集合，使得这些边的总权重最小。...
MST.rar_mst_mst matlab_mst matlab
09-14
【标题】"MST.rar_mst_mst matlab_mst matlab" 涉及到的主要概念是“最小生成树”（Minimum Spanning Tree, MST）和Matlab编程环境的运用。最小生成树是图论中的一个重要算法问题，用于寻找一个无向加权图中连接所有...
mst703_ds_v01.rar_mst703 中文资料_mst703*_mstar_mst单片机_site:www.pudn
07-15
《MST703中文资料深度解析》 MST703是晨星半导体（Mstar）推出的一款高效能视频解码器与TFT液晶屏驱动芯片，它以其卓越的性价比和简洁的外围电路设计在业界赢得了广泛的认可。本文将深入探讨这款芯片的关键特性和...
抓住问题的关键解决LeetCode第3337题字符串转换后的长度II
2302_79682652的博客
11-04 530
将s[i]替换为字母表中后续的nums[s[i]-'a']个连续字符。例如，如果s[i]='y'且nums[24]=3，则字符'y'转换为它后面的3个连续字符，结果为"zab"。输入：s="abcyy",t=2,nums=[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]输入：s="azbk",t=1,nums=[2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
Leetcode 62. 不同路径 动态规划+空间优化
想买很多漂亮衣服但是买不起的博客
11-01 313
【代码】Leetcode 62. 不同路径 动态规划+空间优化。
leetcode动态规划（二十四）-最长递增子序列
weixin_40198632的博客
11-04 373
给你一个整数数组nums，找到其中最长严格递增子序列的长度。是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7]是数组的子序列。4最长递增子序列是 [2,3,7,101]，因此长度为 4。41。
【LeetCode】【算法】160.相交链表
最新发布
passer__jw767的博客
11-05 210
Leetcode 160. 相交链表
【Python3】【力扣题】409. 最长回文串
yannan20190313的博客
11-01 320
【Python3】【力扣题】409. 最长回文串
MST717电源模块电路解析
"晨星MST717原理图是一个PDF文档，包含了开发板的电路设计。这份原理图涉及了电源管理、电压稳压、保护电路等多个方面，是理解和分析MST717芯片在实际应用中的工作原理的重要参考资料。" 在MST717原理图中，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值