单源最短路建图方式例题整理

1129. 热浪（活动 - AcWing）

思路：题目只是加了一个背景，但实际上还是很裸的单源最短路问题。我们有四种写法，bellman_ford算法时间复杂度不如spfa，而且这里对边数没有限定，所以没必要使用bellman_ford。然后我们就时间复杂度进行分析，朴素版dijkstra算法的时间复杂度是O(n^2)，本题的点数是2500，n^2=6250000,数量级1e6，可以过；堆优化的dijkstra，时间复杂度O(mkogn)，6200log2500=21067(约等)，数量级是1e4,也是可以过的；spfa一般时间复杂度是O(m)，m=6200,数量级是1e3，最坏O(nm)=15500000,数量级是1e7，也没问题。那么我们本着复习算法将所有的都写一下。

朴素版dijsktra:

#include<bits/stdc++.h>
using namespace std;
const int N=3000,M=7000;
int n,m;
int s,e;
int g[N][N];
int d[N],st[N];
int dijkstra()
{
    memset(d,0x3f,sizeof d);
    d[s]=0;
    for(int i=1;i<=n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
            if(!st[j]&&(t==-1||d[t]>d[j])) t=j;

        st[t]=1;

        for(int i=1;i<=n;i++)
            if(g[t][i]!=0x3f3f3f3f)
                d[i]=min(d[i],d[t]+g[t][i]);
    }
    if(d[e]!=0x3f3f3f3f) return d[e];
    else return -1;
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&s,&e);
    memset(g,0x3f,sizeof g);
    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        g[a][b]=g[b][a]=min(g[a][b],c);
    }
    cout<<dijkstra();
}

堆优化版dijkstra

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> pii;
const int N=3000,M=7000*2;
int h[N],e[M],ne[M],w[M],idx;
int st[N],d[N];
int n,m,ts,te;
void add(int a,int b,int c)
{
    w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int dijkstra()
{
    memset(d,0x3f,sizeof d);
    d[ts]=0;
    priority_queue<pii,vector<pii>,greater<pii>>q;
    q.push({0,ts});
    while(q.size())
    {
        auto t=q.top();
        q.pop();
        int dist=t.first,v=t.second;
        if(st[v]) continue;
        st[v]=1;
        for(int i=h[v];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]>d[v]+w[i])
            {
                d[j]=d[v]+w[i];
                q.push({d[j],j});
            }
        }
    }
    if(d[te]!=0x3f3f3f3f) return d[te];
    else return -1;
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&ts,&te);
    memset(h,-1,sizeof h);
    for(int i=1;i<=m;i++)
    {
        int a,b,c;                                                                                                                                                                                                           
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c),add(b,a,c);
    }
    cout<<dijkstra();
}

spfa

#include<bits/stdc++.h>
using namespace std;
const int N=3000,M=7000*2;
int n,m,ts,te;
int h[N],e[M],ne[M],w[M],idx;
int d[N],st[N];
void add(int a,int b,int c)
{
    w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int spfa()
{
    queue<int>q;
    memset(d,0x3f,sizeof d);
    d[ts]=0;
    q.push(ts);
    while(q.size())
    {
        auto t=q.front();
        q.pop();
        st[t]=0;
        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]=1,q.push(j);
                }
            }
        }
    }
    if(d[te]!=0x3f3f3f3f) return d[te];
    else return -1;
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&ts,&te);
    memset(h,-1,sizeof h);
    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c),add(b,a,c);
    }
    cout<<spfa();
}

1128. 信使(活动 - AcWing)

思路：这道题很容易想到bfs，相当于从一个点开始往外扩散，不过这题有边权，所以不能用bfs来求解。但是求的是所有哨所受到消息的最小时间，我们可以把每个哨所的最小时间求出来，然后求一个max。

然后就是考虑时间复杂度的问题，朴素版O(n^2)=1e4,堆优化O(mlogn)=400,spfa一般O(m)=200 最坏O(nm)=2e4，所以三种算法都可以，这里还是本着复习的想法全部写一遍。

朴素版dijkstra

#include<bits/stdc++.h>
using namespace std;
const int N=120;
int g[N][N],d[N],st[N];
int n,m;
int dijkstra()
{
    memset(d,0x3f,sizeof d);
    d[1]=0;
    for(int c=0;c<n;c++)
    {
        int t=-1;
        for(int i=1;i<=n;i++)
            if(!st[i]&&(t==-1||d[t]>d[i]))t=i;
    
        st[t]=1;
        for(int i=1;i<=n;i++)
        {
            if(!st[i]&&d[i]>d[t]+g[t][i])
            {
                d[i]=d[t]+g[t][i];
            }
        }
    }
    int flag=1,mx=0;
    for(int i=1;i<=n;i++)
    {
        if(d[i]==0x3f3f3f3f)
        {
            flag=0;
            break;
        }
        mx=max(mx,d[i]);
    }
    if(flag) return mx;
    else return -1;
}
int main()
{
    scanf("%d%d",&n,&m);
    memset(g,0x3f,sizeof g);
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        g[a][b]=g[b][a]=min(g[a][b],c);
    }
    cout<<dijkstra();
}

 堆优化版dijkstra

#include<bits/stdc++.h>
using namespace std;
const int N=110,M=410;
int h[N],e[M],ne[M],w[M],idx;
int n,m;
int d[N],st[N];
void add(int a,int b,int c)
{
    w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
typedef pair<int,int> pii;
int dijkstra()
{
    memset(d,0x3f,sizeof d);
    d[1]=0;
    priority_queue<pii,vector<pii>,greater<pii>>q;
    q.push({0,1});
    while(q.size())
    {
        auto t=q.top();
        q.pop();
        int dist=t.first,v=t.second;
        if(st[v]) continue;
        st[v]=1;
        for(int i=h[v];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]>dist+w[i])
            {
                d[j]=dist+w[i];
                q.push({d[j],j});
            }
        }
    }
    int flag=1,mx=0;
    for(int i=1;i<=n;i++)
    {
        if(d[i]==0x3f3f3f3f) 
        {
            flag=0;
            break;
        }
        mx=max(mx,d[i]);
    }
    if(flag) return mx;
    else return -1;
}
int main()
{
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c),add(b,a,c);
    }
    cout<<dijkstra();
}

spfa

#include<bits/stdc++.h>
using namespace std;
const int N=110,M=410;
int h[N],e[M],ne[M],w[M],idx;
int d[N],st[N];
int n,m;
void add(int a,int b,int c)
{
    w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int spfa()
{
    memset(d,0x3f,sizeof d);
    d[1]=0;
    queue<int>q;
    q.push(1);
    while(q.size())
    {
        int t=q.front();
        q.pop();
        st[t]=0;
        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])
                {
                    q.push(j);
                    st[j]=1;
                }
            }
        }
    }
    int flag=1,mx=0;
    for(int i=1;i<=n;i++)
    {
        if(d[i]==0x3f3f3f3f)
        {
            flag=0;
            break;
        }
        mx=max(mx,d[i]);
    }
    if(flag) return mx;
    else return -1;
}
int main()
{
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c),add(b,a,c);
    }
    cout<<spfa();
}

1127. 香甜的黄油(1127. 香甜的黄油 - AcWing题库)

思路：这题的题意翻译一下就是找一个点，从这个点其他所有点的距离和最小。我们来看，如果一个点到其他点的距离和最小，那么到每个点应该取最短距离，对于每个点我们都要这么求一下，然后取最小值。朴素版dijkstra的时间复杂度是O(n^2)=640000,再乘上p个点，那么就是2e8，2e8的时间复杂度或许能够卡过去，但是不保险；堆优化版O(mlogn)约为4209，再乘上p，差不多3e6，肯定可以过；spfa一般来说是O(m)，最坏O(nm),那么时间复杂度就在1e6~9e8,实际上应该不会卡到2e8的时间复杂度，所以可以试试，不行就换堆优化版的dijkstra。这里我们把spfa和堆优化版dijkstra都写一下。

堆优化版dijkstra

#include<bits/stdc++.h>
using namespace std;
const int N=810,M=3010;
int h[N],e[M],ne[M],w[M],idx;
int d[N],st[N];
int n,p,m;
int id[N];
void add(int a,int b,int c)
{
    w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
typedef pair<int,int> pii;
int dijkstra(int s)
{
    memset(d,0x3f,sizeof d);
    memset(st,0,sizeof st);
    d[s]=0;
    priority_queue<pii,vector<pii>,greater<pii>>q;
    q.push({0,s});
    while(q.size())
    {
        auto t=q.top();
        q.pop();
        int v=t.second,dist=t.first;
        if(st[v]) continue;
        st[v]=1;
        for(int i=h[v];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]>dist+w[i])
            {
                d[j]=dist+w[i];
                q.push({d[j],j});
            }
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++)
    {
        int j=id[i];
        if(d[j]==0x3f3f3f3f) return 0x3f3f3f3f;
        ans += d[j];
    }
    return ans;
}
int main()
{
    scanf("%d%d%d",&n,&p,&m);
    for(int i=1;i<=n;i++) scanf("%d",&id[i]);
    memset(h,-1,sizeof h);
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c),add(b,a,c);
    }
    int res=0x3f3f3f3f;
    for(int i=1;i<=p;i++) res=min(res,dijkstra(i));
    cout<<res;
}

spfa

#include<bits/stdc++.h>
using namespace std;
const int N=810,M=3010,inf=0x3f3f3f3f;
int n,p,m;
int h[N],e[M],ne[M],w[M],idx;
int d[N],st[N],id[N];
void add(int a,int b,int c)
{
    w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int spfa(int s)
{
    memset(d,0x3f,sizeof d);
    d[s]=0;
    queue<int>q;
    q.push(s);
    while(q.size())
    {
        int t=q.front();
        q.pop();
        st[t]=0;
        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]=1;
                    q.push(j);
                }
            }
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++)
    {
        int j=id[i];
        if(d[j]==inf) return inf;
        ans += d[j];
    }
    return ans;
}
int main()
{
    scanf("%d%d%d",&n,&p,&m);
    for(int i=1;i<=n;i++) scanf("%d",&id[i]);
    memset(h,-1,sizeof h);
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c),add(b,a,c);
    }
    int res=inf;
    for(int i=1;i<=p;i++)
    {
        res=min(res,spfa(i));
    }
    cout<<res;
}

1126. 最小花费(活动 - AcWing)

这道题我们已知起点和终点，但是这里不再是加法，不过实际上还是求最小，那么就可以用最短路来考虑，有两种思路，

我们设起点金额是ds，中间经过一系列折损pi,ds*p1*p2*...*pn=de,de确定是100，ds尽可能的小，那么就要这一系列乘积尽可能的大。虽然这里是最大，但是我们存边可以存成实际的百分数，那么就会越乘越小，所以当一个位置第一被作为最大的挑出来的时候，就是此处最大的位置。 

#include<bits/stdc++.h>
using namespace std;
int n,m,s,e;
double g[2010][2010];
int st[2010];
double d[2010];
double dijkstra()
{
    d[s]=1;
    for(int i=1;i<=n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
            if(!st[j]&&(t==-1||d[t]<d[j])) t=j;
        
        st[t]=1;
        
        for(int j=1;j<=n;j++)
            d[j]=max(d[j],d[t]*g[t][j]);
    }
    return 100/d[e];
}
int main()
{
    scanf("%d%d",&n,&m);
    memset(g,0,sizeof g);
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        double z=(100.0-c)/100;
        g[a][b]=g[b][a]=max(g[a][b],z);
    }
    scanf("%d%d",&s,&e);
    double ans=dijkstra();
    printf("%.8lf",ans);
}

另外还有一个思路就是从B往前找，求出最小的A。这时候边权是大于1的，越乘越大，自然可以找到最小值。

#include<bits/stdc++.h>
using namespace std;
int n,m,s,e;
int g[2010][2010],st[2010];
double d[2010];
double dijkstra()
{
    for(int i=1;i<=n;i++) d[i]=1e100;
    d[e]=100.0;
    for(int i=1;i<=n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
        {
            if(!st[j]&&(t==-1||d[j]<d[t])) t=j;
        }
        st[t]=1;
        for(int j=1;j<=n;j++)
        {
            if(st[j]||g[t][j]==0x3f3f3f3f) continue;
            double p=(100-g[t][j])/100.0;
            d[j]=min(d[j],d[t]/p);
        }
    }
    return d[s];
}
int main()
{
    scanf("%d%d",&n,&m);
    memset(g,0x3f,sizeof g);
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        g[a][b]=g[b][a]=min(g[a][b],c);
    }
    scanf("%d%d",&s,&e);
    double ans=dijkstra();
    printf("%.8lf",ans);
}

920. 最优乘车(920. 最优乘车 - AcWing题库)

 这里要获得最少换乘次数，而且公交线路是单程的，看似很麻烦，我们可以这么来处理，我们计算出最少坐车次数，用这个减1就是最少换乘次数。那么这个坐车次数该怎么求呢，我们可以将同一线路中的点之间，按照车到站的顺序连一条边权为1的边。然后去搜到终点的最短路。

#include<bits/stdc++.h>
using namespace std;
int m,n;
int g[600][600];
int d[600];
int id[600];
void bfs()
{
    memset(d,0x3f,sizeof d);
    d[1]=0;
    queue<int>q;
    q.push(1);
    while(q.size())
    {
        auto t=q.front();
        q.pop();
        for(int i=1;i<=n;i++)
            if(g[t][i]&&d[i]>d[t]+1)
            {
                d[i]=d[t]+1;
                q.push(i);
            }
    }
}
int main()
{
    scanf("%d%d",&m,&n);
    string s;
    getline(cin,s);
    while(m--)
    {
        getline(cin,s);
        stringstream ss(s);
        int cnt=0,p;
        while(ss>>p) id[cnt++]=p;
        for(int i=0;i<cnt;i++)
            for(int j=i+1;j<cnt;j++)
                g[id[i]][id[j]]=1;
    }
    bfs();
    if(d[n]==0x3f3f3f3f) printf("NO");
    else printf("%d",d[n]-1);
}

903. 昂贵的聘礼(活动 - AcWing)

 思路：这题乍一看没什么头绪，但是每一个个物品我们有多种获取方式，这里可以联想到dp，由于情况太多，进一步联想到建图。我们先来分析样例，样例中等级没有什么限制那么就先不管。如果一个物品可以替换另一物品那么我们就建一条有向边。

这样物品与物品之间的关系就很清楚了，但是这个图从什么地方开始循环还是不明朗的。而且用原价买这种方式应该也要建一条边，我们的图中并没有体现出来。那么我们可以假定一个虚拟原点。 

那么很显然我们可以从虚拟原点出发，找到一个到1距离最短的路径。

然后就是等级问题，这里合法的对象肯定是在一个合法区间中间，也就是区间左右的等级差是m。另外还要注意一点，酋长的等级不一定最高，所以我们要把酋长作为左端点和作为右端点的情况都考虑到。这里N的范围是100以内，然后我们差不多要进行M次查找，所以这里可以用朴素版dijkstra，时间复杂度差不多是1e6。

#include<bits/stdc++.h>
using namespace std;
int p[120],level[120],g[120][120];
int m,n;
int d[120],st[120];
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;i++)
    {
        int t=-1;
        for(int j=0;j<=n;j++)
        {
            if(!st[j]&&(t==-1||d[t]>d[j])) t=j;
        }
        st[t]=1;
        for(int j=1;j<=n;j++)
        {
            if(g[t][j]&&down<=level[j]&&level[j]<=up)
                d[j]=min(d[j],d[t]+g[t][j]);
        }
    }
    return d[1];
}
int main()
{
    scanf("%d%d",&m,&n);
    for(int i=1;i<=n;i++)
    {
        int c;
        scanf("%d%d%d",&p[i],&level[i],&c);
        g[0][i]=p[i];
        for(int j=1;j<=c;j++)
        {
            int in,d;
            scanf("%d%d",&in,&d);
            g[in][i]=d;
        }
    }
    int res=0x3f3f3f3f;
    for(int i=level[1]-m;i<=level[1];i++) res=min(res,dijkstra(i,i+m));
    cout<<res;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/388369.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【JAVA-Day77】Java线程继承Thread类实现Runnable接口

【JAVA-Day77】Java线程继承Thread类实现Runnable接口

Java线程继承Thread类实现Runnable接口 《Java线程编程指南&#xff1a;轻松掌握线程的创建和启动》摘要 &#x1f60a;引言 &#x1f680;一、什么是进程和线程 ❓二、线程如何创建 &#x1f60e;2.1 继承Thread类并重写run()方法 &#x1f4dd;2.2 实现Runnable接口并实现run…
阅读更多...
jvm 内存模型介绍

jvm 内存模型介绍

一、类加载子系统 1、类加载的过程&#xff1a;装载、链接、初始化&#xff0c;其中&#xff0c;链接又分为验证、准备和解析 装载&#xff1a;加载class文件 验证&#xff1a;确保字节流中包含信息符合当前虚拟机要求 准备&#xff1a;分配内存&#xff0c;设置初始值 解析&a…
阅读更多...
Protégé pizza 03 Install Protege - 本体编辑器 Ontology Editor

Protégé pizza 03 Install Protege - 本体编辑器 Ontology Editor

Protege是一款非常方便使用的开源的本体&#xff08;ontology&#xff09;编辑器&#xff0c;可以用来建立知识图谱。 这个视频介绍了Protege工具的安装&#xff0c;是学习pizza.owl系列知识的前提。 https://v.youku.com/v_show/id_XNjE1NDc0NTU3Mg.html
阅读更多...
【JAVA】计算机软件工程人工智能研究生复试资料整理

【JAVA】计算机软件工程人工智能研究生复试资料整理

1、JAVA 2、计算机网络 3、计算机体系结构 4、数据库 5、计算机租场原理 6、软件工程 7、大数据 8、英文 自我介绍 1. Java 1. == 和 equals的区别 比较基本数据类型是比较的值，引用数据类型是比较两个是不是同一个对象，也就是引用是否指向同 一个对象，地址是否相同，equ…
阅读更多...
精读Relational Embedding for Few-Shot Classification (ICCV 2021)

精读Relational Embedding for Few-Shot Classification (ICCV 2021)

Relational Embedding for Few-Shot Classification (ICCV 2021) 一、摘要 该研究提出了一种针对少样本分类问题的新方法&#xff0c;通过元学习策略来学习“观察什么”和“在哪里关注”。这种方法依赖于两个关键模块&#xff1a;自相关表示&#xff08;SCR&#xff09;和交叉…
阅读更多...
OS内存管理

OS内存管理

内存 定义 内存是计算机用于存储数据和程序的硬件设备&#xff0c;它允许计算机快速读取和写入数据。内存通常是临时存储&#xff0c;其内容在计算机关闭或断电时会丢失。内存可存放数据。程序执行前需要先放到内存中才能被CPU处理(缓和CPU与硬盘之间的速度矛盾)。 在多道程…
阅读更多...
ZBX_NOTSUPPORTED: Unsupported item key. 原因排查

ZBX_NOTSUPPORTED: Unsupported item key. 原因排查

进行自定义监控项时&#xff0c;在zabbix-agent端测试没问题&#xff0c;却在zabbix-server进行测试时&#xff0c;出现 ZBX_NOTSUPPORTED: Unsupported item key. 1.在zabbix-agent测试没问题&#xff0c;证明自定义监控项的脚本没问题&#xff0c;却在zabbix-server端测试出…
阅读更多...
表的连接

表的连接

目录 内连接实现效果 使用左外连接&#xff0c;将所有的员工信息都显示出来&#xff0c;即便他没有对应的部门 使用右外连接&#xff0c;将所有的部门信息都显示出来 查询每个员工的编号、姓名、职位&#xff0c;以及所在各部门的领导姓名、领导职位 确定所需要的数据表 确…
阅读更多...
IMX6ULL移植U-Boot 2022.04

IMX6ULL移植U-Boot 2022.04

目录 目录 1.编译环境以及uboot版本 2.默认编译测试 3.uboot中新增自己的开发板 3.编译测试 4.烧录测试 5.patch文件 1.编译环境以及uboot版本 宿主机Debian12u-boot版本lf_v2022.04 ; git 连接GitHub - nxp-imx/uboot-imx: i.MX U-Boot交叉编译工具gcc-arm-10.3-2021.0…
阅读更多...
机器学习：卷积介绍及代码实现卷积操作

机器学习：卷积介绍及代码实现卷积操作

传统卷积运算是将卷积核以滑动窗口的方式在输入图上滑动&#xff0c;当前窗口内对应元素相乘然后求和得到结果&#xff0c;一个窗口一个结果。相乘然后求和恰好也是向量内积的计算方式&#xff0c;所以可以将每个窗口内的元素拉成向量&#xff0c;通过向量内积进行运算&#xf…
阅读更多...
关于nuclei-ai-extension

关于nuclei-ai-extension

nuclei-ai-extension &#x1f341; Nuclei 官方开发的 利用 AI 生成 nuclei 模板的工具。Nuclei AI - 用于快速生成 Nuclei 模板的浏览器扩展&#xff0c;Nuclei AI Browser Extension建立在 cloud.projectdiscovery.io 之上&#xff0c;使用户能够从任何网页中提取漏洞信息&…
阅读更多...
设计模式之创建型模式

设计模式之创建型模式

创建型模式提供创建对象的机制,能够提升已有代码的灵活性和复用性 常用的有&#xff1a;单例模式、工厂模式&#xff08;工厂方法和抽象工厂&#xff09;、建造者模式。 不常用的有&#xff1a;原型模式。 4.1 单例模式 创建型模式提供创建对象的机制,能够提升已有代码的灵…
阅读更多...
【MATLAB】在图框中加箭头文本注释

【MATLAB】在图框中加箭头文本注释

1、在图框中加 文本方法 —— text&#xff08;&#xff09;函数 2、使用箭头标注——annotation&#xff08;&#xff09;函数 X、Y是箭头的位置相对于整个方框的比例&#xff0c; [0.32,0.5]是指&#xff1a;x坐标从整个图形32%的地方到50%的地方&#xff08;从左到右&…
阅读更多...
基于laravel开发的开源交易所源码|BTC交易所/ETH交易所/交易所/交易平台/撮合交易引擎

基于laravel开发的开源交易所源码|BTC交易所/ETH交易所/交易所/交易平台/撮合交易引擎

开源交易所&#xff0c;基于Laravel开发的交易所 | BTC交易所 | ETH交易所 | 交易所 | 交易平台 | 撮合交易引擎。本项目有完整的撮合交易引擎源码、后台管理&#xff08;后端前端&#xff09;、前台&#xff08;交易页面、活动页面、个人中心等&#xff09;、安卓APP源码、苹果…
阅读更多...
【蓝桥杯单片机入门记录】认识单片机

【蓝桥杯单片机入门记录】认识单片机

目录 单片机硬件平台 单片机的发展过程 单片机开发板 单片机基础知识 电平 数字电路中只有两种电平&#xff1a;高和低 二进制&#xff08;8421码&#xff09; 十六进制 二进制数的逻辑运算 “与” “或” “异或” 标准C与C51 如何学好单片机 端正学习的态度、培…
阅读更多...
BUGKU-WEB 矛盾

BUGKU-WEB 矛盾

题目描述 进入场景看看&#xff1a; 代码如下&#xff1a; $num$_GET[num]; if(!is_numeric($num)) { echo $num; if($num1) echo flag{**********}; }解题思路 需要读懂一下这段PHP代码的意思明显是一道get相关的题目&#xff0c;需要提供一个num的参数,然后需要传入一个不…
阅读更多...
CSGO搬砖项目怎么样？分享一下个人的看法！

CSGO搬砖项目怎么样？分享一下个人的看法！

对于steam搬砖平台&#xff0c;无人不知&#xff0c;无人不晓啊&#xff0c;全球最大的一个游戏平台&#xff0c;像我们知道的PUBG&#xff0c;CS:GO&#xff0c;都是里面的&#xff0c;比较火的一个平台。 对于想了解Steam搬砖的&#xff0c;今天分享一下个人的看法。 首先&a…
阅读更多...
【C语言】数据结构#实现堆

【C语言】数据结构#实现堆

目录 &#xff08;一&#xff09;堆 &#xff08;1&#xff09;堆区与数据结构的堆 &#xff08;二&#xff09;头文件 &#xff08;三&#xff09;功能实现 &#xff08;1&#xff09;堆的初始化 &#xff08;2&#xff09;堆的销毁 &#xff08;3&#xff09;插入数据 …
阅读更多...
java中stream流中的concat合并操作

java中stream流中的concat合并操作

可以用stream.of来合并两个流 public class Test7concat {public static void main(String[] args) {/*Stream流:static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b);合并2个流中的元素*/Stream<String> stream1 St…
阅读更多...
石子合并+环形石子合并+能量项链+凸多边形的划分——区间DP

石子合并+环形石子合并+能量项链+凸多边形的划分——区间DP

一、石子合并 (经典例题) 设有 N 堆石子排成一排&#xff0c;其编号为 1,2,3,…,N。 每堆石子有一定的质量&#xff0c;可以用一个整数来描述&#xff0c;现在要将这 N 堆石子合并成为一堆。 每次只能合并相邻的两堆&#xff0c;合并的代价为这两堆石子的质量之和&#xff0c;…
阅读更多...
最新文章

Copyright @ 2022~2023