单源最短路建图

最新推荐文章于 2024-10-13 16:52:53 发布
最新推荐文章于 2024-10-13 16:52:53 发布
阅读量236 收藏
点赞数
文章标签： 算法 图论 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60343477/article/details/129827270
版权

单源最短路的建图方式

1.1129. 热浪

在这里插入图片描述

思路：
将问题化简一下：
求x到y的最小距离（这里花费等价于距离）

那么使用4种基本模板：

  1. dijkstra朴素做法
  2. dijkstra优化做法
  3. bellman_ford算法
  4. spaf算法（bellman_ford)算法

由于是刚开始写，所以说明每个算法的基本逻辑，但是很明显做法2和做法4是优先考虑的（因为是优化版嘛）

这里用四个方法解决这道最简单的求单源路径最短问题

1.dijstra朴素版

//dijkstra朴素版

#include<iostream>
#include<cstring>
using namespace std;

const int N=2510,M=6200*2+10;

int d[N];  //d[i]=j表示点i距离源点的距离是j（源点就是起点）、
bool st[N];  //记录哪些点被找过

int h[N],e[M],ne[M],w[M];   //构建邻接表
int idx;

int n,c,start,End;//n个点，c条双向边,start是起点，end是终点

void add(int a,int b,int c)
{
    e[idx]=b;  //新节点
    ne[idx]=h[a];  //新节点的下一个节点指向h[a]的下一个节点（头插法）,h[a]是a的邻接表
    //比如原来：  a->c->d->null
    //现在：  a  b->c->d->null
    w[idx]=c;  //新边的权值
    h[a]=idx++;  //然后h[a]指向新节点，就完成了a->b->c->d->null(原来a的下一个节点)
}

void dijkstra()  //朴素dijkstra
{
    //每次找到距离源点最近的点x，然后以x为中心更新其他的点（距离只要比原来小就更新）
    memset(d,0x3f,sizeof d);
    d[start]=0;
    // for(int i=h[start];i!=-1;i=ne[i])
    // {
    //     int j=e[i];
    //     d[j]=w[i];
    // }
    
    for(int i=0;i<n;i++)  //每次都可以确定一个点到源点的距离最小,那么需要找n次，源点也算
    {
        int t=-1;
        for(int j=1;j<=n;j++)  //找到距离源点最近的点
        {
            if(!st[j]&&(t==-1||d[t]>d[j]))
                t=j;
        }
        
        st[t]=true;  //表示t点到源点的最短距离就此确定。
        //这一步很巧秒，用反证法证明：此时t是所有点中距离源点最近的点
        //如果t不是距离源点最近的点，那么一定有其他点经过若干边距离源点更近，
        //但是此时t已经是距离源点最近的点了，单凡t或者其他点再经过任意一个边，到达源点
        //的距离都一定大于此时的t到源点的距离（没有负边的情况）
        
        
        //接下来是通过t更新距离源点更加近的点
        for(int j=h[t];j!=-1;j=ne[j])
        {
            int k=e[j];
            if(st[k])continue;
            d[k]=min(d[k],d[t]+w[j]);
        }
    }
        
    
}

int main()
{
    
    cin>>n>>c>>start>>End;   
    
    memset(h,-1,sizeof h);  //初始化邻接表
    
    for(int i=0;i<c;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    
    dijkstra();
    cout<<d[End];
    
    return 0;
}

2.优化版dijkstra

#include<iostream>
#include<queue>
#include<vector>
#include<cstring>
using namespace std;

const int N=2510,M=6200*2+10;

typedef pair<int,int> PII;
int h[N],e[M],ne[M],w[M],idx;


int d[N];
bool st[N];


int n,c,ts,td;

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

void dijkstra()
{
    memset(d,0x3f,sizeof d);
    d[ts]=0;
    priority_queue<PII,vector<PII>,greater<PII>>heap;   //距离源点的距离被排好序，这是优化的唯一步骤
    heap.push({0,ts}); //first是距离，second是节点编号
    while(heap.size())  
    {
        auto t=heap.top();
        heap.pop();
        int distance=t.first,ver=t.second;
        
        if(st[ver])continue;
        st[ver]=true;
        
        for(int i=h[ver];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(st[j])continue;
            if(distance+w[i]<d[j])
            {
                d[j]=distance+w[i];
                heap.push({d[j],j});
            }
        }
    }
    
}

int main()
{
    cin>>n>>c>>ts>>td;
    
    memset(h,-1,sizeof h);
    while(c--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    
    dijkstra();
    
    cout<<d[td];
    return 0;
    
}

3.bellman_ford算法
说一句，可能不对，但是这个算法好像floyd算法啊，就是不停对边进行松弛

#include<iostream>
#include<cstring>
using namespace std;


const int N=2510,M=20000;

int h[N],ne[M],e[M],w[M],idx;
int d[N];
int backup[N];


int n,c,ts,td;

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

void bellman_ford()
{
    memset(d,0x3f,sizeof d);
    
    d[ts]=0;
    
    for(int i=1;i<=n;i++)  //对n条边进行松弛
    {
        memcpy(backup,d,sizeof d);
        for(int j=1;j<=n;j++)  //对n个点都作为起点尝试松弛经过点j的点到源点的最短距离
        {
            for(int a=h[j];a!=-1;a=ne[a])
            {
                int b=e[a];
                d[b]=min(d[b],backup[j]+w[a]);
            }
        }
    }
}


int main()
{
    cin>>n>>c>>ts>>td;
    memset(h,-1,sizeof h);
    
    while(c--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    
    bellman_ford();
    cout<<d[td];
    
    return 0;
}

4.spaf算法
Bellman_ford算法会遍历所有的边，但是有很多的边遍历了其实没有什么意义，我们只用遍历那些到源点距离变小的点所连接的边即可，只有当一个点的前驱结点更新了，该节点才会得到更新；因此考虑到这一点，我们将创建一个队列每一次加入距离被更新的结点。

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;


const int N=2510,M=20000;

int h[N],ne[M],e[M],w[M],idx;
int d[N];
bool st[N];


int n,c,ts,td;

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

void spfa()
{
    memset(d,0x3f,sizeof d);
    queue<int>q;
    q.push(ts);
    d[ts]=0;
    st[ts]=true;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        st[t]=false;
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]>d[t]+w[i])  //如果从t到源点的距离加上t到j的距离小于j到源点的距离，那么进行松弛操作。
            {
                //注意，如果j在队列里面，不需要加入（队列里面的元素都是被其前驱点更新过的点，这些有用的点去继续更新其他点）
                d[j]=d[t]+w[i];
                if(!st[j])
                {
                    st[j]=true;
                    q.push(j);
                }
            }
        }
    }
}

int main()
{
    cin>>n>>c>>ts>>td;
    memset(h,-1,sizeof h);
    
    while(c--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    
    spfa();
    cout<<d[td];
    
    return 0;
}

2.1128.信使

在这里插入图片描述

任意选一个模板，找到点1到最远的那个点的距离

#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>

using namespace std;


const int N=110,M=410;

int h[N],e[M],ne[M],w[M],idx;

int d[N];
bool st[N];


int n,m;

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

void spaf()
{
    memset(d,0x3f,sizeof d);
    queue<int>q;
    q.push(1);
    d[1]=0;
    st[1]=true;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        
        st[t]=false;
        
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]>d[t]+w[i])
            {
                d[j]=d[t]+w[i];
                if(!st[j])
                {
                    st[j]=true;
                    q.push(j);
                }
            }
        }
    }
}

int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof h);
    
    while(m--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    spaf();
    
    int res=0;
    for(int i=1;i<=n;i++)
    {
        if(d[i]>0x3f3f3f3f/2)
        {
            res=-1;
            break;
        }
        else if(d[i]>res)
        {
            res=d[i];
        }
    }
    cout<<res<<endl;
    return 0;
    
}

floyd算法写的(yxc的方法）

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int d[N][N];

int main()
{
    cin >> n >> m;

    memset(d, 0x3f, sizeof d);
    for (int i = 1; i <= n; i ++ ) d[i][i] = 0;
    for (int i = 0; i < m; i ++ )
    {
        int a, b, c;
        cin >> a >> b >> c;
        d[a][b] = d[b][a] = min(d[a][b], c);
    }

    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);

    int res = 0;
    for (int i = 1; i <= n; i ++ )
        if (d[1][i] == INF)
        {
            res = -1;
            break;
        }
        else res = max(res, d[1][i]);

    cout << res << endl;

    return 0;
}

3.1127. 香甜的黄油

在这里插入图片描述

多源汇最短路问题：
标准做法：
1.floyd算法（n3)
2.使用n次dijkstra优化版(n* m *log2n)
3.使用 n次spaf算法(m * n)

思路：枚举所有点为起点，计算起点到所有牛的最短路径的和。
找出这些起点中之和最短的那个起点

#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>

using namespace std;


const int N=3000;

int h[N],e[N],ne[N],w[N],idx;
int d[N];
bool st[N];

int mm[N];

int n,p,c;//奶牛数 N，牧场数 P，牧场间道路数 C。


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

void spaf(int start)
{
    memset(st,false,sizeof st);
    memset(d,0x3f,sizeof d);
    queue<int>q;
    q.push(start);
    st[start]=true;
    d[start]=0;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        
        st[t]=false;
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]>d[t]+w[i])
            {
                d[j]=d[t]+w[i];
                if(!st[j])
                {
                    st[j]=true;
                    q.push(j);
                }
            }
        }
    }
    
}


int main()
{
    cin>>n>>p>>c;
    for(int i=0;i<n;i++)
    {
        int x;
        cin>>x;
        mm[i]=x;
    }
    
    memset(h,-1,sizeof h);
    while(c--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    
    int res=0x3f3f3f3f;
    for(int i=1;i<=p;i++)  //枚举每个点作为汇集点
    {
        spaf(i);
        int sum=0;
        for(int j=0;j<n;j++)
        {
           if(d[mm[j]]==0x3f3f3f3f)
           {
               sum=0x3f3f3f3f;
               break;
           }
           sum+=d[mm[j]];
        }
        res=min(res,sum);
    }
    
    cout<<res;
    return 0;
    
}

4.903. 昂贵的聘礼

在这里插入图片描述

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;


const int N=110;
int w[N][N],level[N];

int d[N];
bool st[N];

int n,m;


int dijkstra(int down,int up)
{
    memset(d,0x3f,sizeof d);
    memset(st,0,sizeof st);
    
    d[0]=0;
    for(int i=1;i<=n+1;i++)
    {
        int t=-1;
        for(int j=0;j<=n;j++)
            if(!st[j]&&(t==-1||d[t]>d[j]))
                t=j;
        st[t]=true;
        for(int j=1;j<=n;j++)
        {
            if(level[j]>=down&&level[j]<=up)
                d[j]=min(d[j],d[t]+w[t][j]);
        }
    
    }
    
    return d[1];
}


int main()
{
    cin>>m>>n;
    memset(w,0x3f,sizeof w);
    for(int i=1;i<=n;i++)
        w[i][i]=0;
    
    for(int i=1;i<=n;i++)
    {
        int price,cnt;
        cin>>price>>level[i]>>cnt;
        w[0][i]=min(w[0][i],price);
        
        while(cnt--)
        {
            int id,cost;
            cin>>id>>cost;
            w[id][i]=min(w[id][i],cost);
        }
        
    }
    
    int res=0x3f3f3f3f;
    for(int i=level[1]-m;i<=level[1];i++)
        res=min(res,dijkstra(i,i+m));
        
    cout<<res;
    return 0;
}

5.1126. 最小花费

在这里插入图片描述

#include<iostream>
#include<cstring>
#include<queue>

using namespace std;

const int N=200010;

int h[N],ne[N],idx,e[N];
double w[N];

double d[N];

bool st[N];



int n,m,ts,td;

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

void spaf()
{
    queue<int>q;
    d[ts]=1.0;
    q.push(ts);
    st[ts]=true;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        
        st[t]=false;
        
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]<d[t]*w[i])
            {
                d[j]=d[t]*w[i];
                if(!st[j])
                {
                    st[j]=true;
                    q.push(j);
                }
                
            }
        }
    }
}

int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof h);
    
    while(m--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        double z=(100.0-c)/100;
        add(a,b,z);
        add(b,a,z);
        
    }
    
    cin>>ts>>td;
    
    spaf();
    printf("%.8lf",100/d[td]);
    return 0;
    
}

6.920. 最优乘车

在这里插入图片描述

#include<iostream>
#include<cstring>
#include<algorithm>
#include<sstream>

using namespace std;


const int N=550;

int m,n;
bool g[N][N];
int d[N];
int stop[N];
int q[N];

void bfs()  //找到距离源点最近的点
{
    memset(d,0x3f,sizeof d);
    int hh=0,tt=0;
    d[1]=0;
    q[0]=1;
    while(hh<=tt)
    {
        int t=q[hh++];
        
        for(int i=1;i<=n;i++)
        {
            if(g[t][i]&&d[i]>d[t]+1)  //任意两个点的距离都被抽象为1
            {
                d[i]=d[t]+1;
                q[++tt]=i;
            }
        }
    }
}


int main()
{
    cin>>m>>n;
    string line;
    getline(cin,line);  //读取换行
    
    while(m--)
    {
        getline(cin,line);
        stringstream ss(line);
        int cnt=0,p;
        while(ss>>p)stop[cnt++]=p;
        
        for(int i=0;i<cnt;i++)
            for(int j=i+1;j<cnt;j++)
                g[stop[i]][stop[j]]=true;
    }
    
    bfs();
    
    if(d[n]==0x3f3f3f3f)puts("NO");
    else cout<<max(d[n]-1,0)<<endl;
    
    return 0;
    
    
}
哆啦刘小洋
关注
单源最短路建图问题
nidayededaye2的博客
08-09 324
单元最短路问题
单源最短路建图方式例题整理
m0_74120503的博客
02-14 999
然后我们就时间复杂度进行分析，朴素版dijkstra算法的时间复杂度是O(n^2)，本题的点数是2500，n^2=6250000,数量级1e6，可以过；虽然这里是最大，但是我们存边可以存成实际的百分数，那么就会越乘越小，所以当一个位置第一被作为最大的挑出来的时候，就是此处最大的位置。然后去搜到终点的最短路。然后就是考虑时间复杂度的问题，朴素版O(n^2)=1e4,堆优化O(mlogn)=400,spfa一般O(m)=200 最坏O(nm)=2e4，所以三种算法都可以，这里还是本着复习的想法全部写一遍。
【AcWing单源最短路建图】1126. 最小花费
weixin_62528401的博客
11-09 268
用最短路求边权积最值
【Acwing】【单源最短路建图】920. 最优乘车
weixin_62528401的博客
11-10 184
单源最短路建图
一.1.最优乘车 《bfs+dijkstra》——（图论进阶）单源最短路建图方式
J_X0110的博客
03-25 364
1.题目描述： H 城是一个旅游胜地，每年都有成千上万的人前来观光。 为方便游客，巴士公司在各个旅游景点及宾馆，饭店等地都设置了巴士站并开通了一些单程巴士线路。 每条单程巴士线路从某个巴士站出发，依次途经若干个巴士站，最终到达终点巴士站。 一名旅客最近到 HH 城旅游，他很想去 SS 公园游玩，但如果从他所在的饭店没有一路巴士可以直接到达 SS 公园，则他可能要先乘某一路巴士坐几站，再下来换乘同一站台的另一路巴士，这样换乘几次后到达 SS 公园。 现在用整数 1,2,…N1,2,…N 给 HH 城
[最短路] aw903. 昂贵的聘礼(单源最短路建图+超级源点+知识理解+好题)
Y-puyu 的博客
07-03 176
文章目录1. 题目来源2. 题目解析 1. 题目来源 链接：903. 昂贵的聘礼 2. 题目解析 典型阅读理解题目，模拟样例理解的更快。 简单理解下题意：n 个人，每个人有自己的物品和价格和等级，如果要得到这个人的物品有两种方式： 第一种：直接在他手里买他的物品 第二种：每个人有自己喜欢的其他人的物品，如果自己手里恰好有这个物品，那么可以将这个物品给他，并补偿一定的差价即可获得他的物品。 注意，每个人都有等级。我们的目的是花最少的钱得到 1 号点的物品，并且在整个交易过程中，交易过程中的每个人的等级与
[最短路] aw920. 最优乘车(单源最短路建图+bfs最短路模型+知识理解+好题)
Y-puyu 的博客
07-02 225
文章目录1. 题目来源2. 题目解析 1. 题目来源 链接：920. 最优乘车 相关：[Hbfs] lc815. 公交路线(建图+多源bfs+bfs最短路+思维+好题) 2. 题目解析 以为和 [Hbfs] lc815. 公交路线(建图+多源bfs+bfs最短路+思维+好题) 是一样的题… 然而写完后疯狂报错：发现本题的公交线路是单向的，终点不能到起点。 而力扣是循环的，终点可以到起点。 力扣的建图方式是无向图，显然就不对了… 建图方式： 一个公交线路中，前面的站台可以通达后面的所有站台。那就直接连一
Acwing 920. 最优乘车 （bfs 单源最短路建图 getline
Minelois的博客
07-28 123
添加链接描述 #include<bits/stdc++.h> using namespace std; const int N=510; int g[N][N],arr[N]; int dist[N],vis[N]; int m,n; void bfs(){ memset(dist,0x3f,sizeof dist); queue<int>q; q.push(1); dist[1]=0; while(q.size()){ int
[最短路] aw1127. 香甜的黄油(单源最短路建图+模板题)
Y-puyu 的博客
06-22 136
文章目录1. 题目来源2. 题目解析 1. 题目来源 链接：1127. 香甜的黄油 相关链接： [图+最短路+模板] 五大最短路常用模板) 2. 题目解析 每个牧场都可以当做最短路起点，相当于多源最短路。 数据范围比较敏感，800 个牧场，选出一个作为放糖牧场，使所有在牧场上的奶牛到该放糖牧场的距离和最小。 相当于是确定一个放糖牧场，使其到其他牧场的距离和最短。 显然就是一个最短路问题，可以直接 Floyd 多源最短路求解，但是时间复杂度太高 8003=5.12×108800^3=5.12 \times
单源最短路的建图方式
m0_57193124的博客
05-31 138
题目1：热浪 分析： 由题目可知，求的是两个点之间的最短距离，边权为正数且点数和边数属于同一量级，使用堆优化版的dijkstra进行求解即可。 这道题是无向图，我们建有向图能求解吗？ 不能。 因为如果a 和 b有一条边， 我们只建一条有向边， 意味着 a能到b, b确不能到a， 如果输入时起点是b，终点是a，那么我们就到达不了a，答案出错。 关于能否只建有向图求解无向图的问题， 一定要证明，如果证明不出来，直接按题目要求建立无向图。 时间复杂度：O(m∗logm)O(m * log ^m)O(m∗logm)
【AcWing算法提高课】3.1.1单源最短路的建图方式
m0_71477690的博客
01-23 134
AcWing算法提高课 3.1.1单源最短路的建图方式
图论：单源最短路的建图方式（二分 + dijkstra/spfa/双端队列bfs）
m0_66252872的博客
05-24 240
最近考试周，一周多没写题解了。最近两天题都刷不成~ε=(´ο｀*)))唉。 今天抽时间做了几道题，这道题我觉得学习价值很大，囊括了很多的知识点，并且本题的建图方式也值得学习。分享给大家~ 🎁题目:通信线路 在郊区有N座通信基站，P条双向电缆，第i条电缆连接基站 Ai和 Bi。 特别地，1号基站是通信公司的总站，N号基站位于一座农场中。 现在，农场主希望对通信线路进行升级，其中升级第i条电缆需要花费Li。 电话公司正在举行优惠活动。 农产主可以指定一条从1号基...
最佳路线AcWing(单源最短路+反向建图)
weixin_46503238的博客
05-11 117
我们的出发点有许多个，但是终点只有一个，所以我们可以反向建图，化终点为起点，起点为终点，求最短路。
【基础算法】【ACM】差分约束系统与最短路算法
foreyes_1001的博客
11-19 773
朴素差分约束系统的求解 朴素的差分约束系统是一个不等式组的集合，集合中每一个不等式都形如Ai – Aj &lt;= Xk。对差分约束系统的求解也就是要对不等式组求得任意一组或者满足某种最优性质的一组可行解。差分约束系统在各种计算机和实际的调度问题中都有应用，也可以对某些优化问题的求解提供帮助。   最朴素的差分约束系统可以将不等式组的求解转换成有向图上的单源最短路求解问题，可以利用Dijks...
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 997
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
在顺序结构和链式结构的线性表上实现顺序检索算法
最新发布
m0_56332819的博客
10-13 100
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1345
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
力扣10.13
qq_40052678的博客
10-13 306
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
单源最短路是什么意思
08-17
单源最短路问题是在给定一个图和一个起点，求解从该起点到图中所有其他顶点的最短路径的问题。最短路径是指在图中从起点到目标顶点的路径中，使得路径上所有边的权值和最小的路径。这个问题可以应用于许多实际生活...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值