算法基础第三章

news2024/11/23 15:12:52

算法基础第三章

  • 1、dfs(深度搜索)
    • 1.1、 递归+回溯
    • 1.2、递归+剪枝（剪枝就是判断接下来的递归都不会满足条件，直接回溯，不再继续往下无意义的递归）
  • 2、bfs(广度搜索)
    • 2.1、最优路径（只适合于边权都相等的题）
  • 3、邻接表存储树和图(邻接表就是单链表 ）
    • 3.1、深度优先遍历（特殊的深搜）
    • 3.2、宽度优先遍历（特殊的宽搜）
    • 3.3、有向图的拓扑序列(有环的有向图不可能是拓扑序列)
  • 4、最短路
    • 4.1、单源最短路
      • 4.1.1、所有边权都是整数
      • 4.1.2、存在负权边
    • 4.2、多源汇最短路
  • 5、最小生成树
    • 5.1、prim算法
    • 5.2、Kruskal算法（稀疏图）
  • 6、二分图
    • 6.1、染色法
    • 6.2、匈牙利算法

1、dfs(深度搜索)

1.1、 递归+回溯

  • 解析：下图为1，2，3三个数的全排列过程，从0层开始，一直往下递归，直到数的个数用完，每次使用了一个数需要将这个数标记为已使用过，回溯的时候再恢复为未使用过。
    在这里插入图片描述
  • 题目链接：一个数的全排列
  • 代码
#include <iostream>
#include<stdio.h>//加了这个头文件时间快了1ms

using namespace std;

const int N = 7;
bool use[N];//这个数被用过的话则记为true，排列的时候位置上只能放没被用过的
int path[N],n;
void dfs(int num)
{
    if(num == n)//输入3,怎有3个空位排列，填满之后就输出
    {
        for(int i = 0; i < n; i++)
        {
            printf("%d ",path[i]);
        }
        puts("");
        return;
    }
    for(int i = 1; i <= n; i++)
    {
        if(!use[i])
        {
            path[num] = i;
            use[i] = true;
            dfs(num + 1);
            use[i] = false;
        }
    }
}

int main() {
    cin >> n;
    dfs(0);//从0开始
    return 0;
}

1.2、递归+剪枝（剪枝就是判断接下来的递归都不会满足条件，直接回溯，不再继续往下无意义的递归）

  • 解析：
  • 题目链接：n皇后问题
  • 代码：代码并没有全a，路过的大佬可以给个补充
#include <iostream>
using namespace std;

const int N = 20;
int n;
bool col[N],dg[N],udg[N];
long long ret;

void dfs(int num)
{
    if(num == n)
    {
        ret++;
        return;
    }
    for(int i = 0; i < n; i++)
    {
        if(!col[i] && !dg[i+num] && !udg[n-num+i])
        {
            col[i] = dg[i+num] = udg[n-num+i] = true;
            dfs(num+1);
            col[i] = dg[i+num] = udg[i-num+n] = false;
        }
    }
}
int main() {
    scanf("%d",&n);
    dfs(0);
    printf("%lld",ret);
}

2、bfs(广度搜索)

//基本框架，伪代码
queue_init;
while(!queue.empty())
{
	t = queue.pop();//弹出队头元素
	queue.push(t.child->node);//这里包括左右子节点
}

2.1、最优路径（只适合于边权都相等的题）

  • 解析：
  • 题目链接：走迷宫
  • 代码
#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

typedef pair<int,int> PII;

const int N = 1010;
char g[N][N];//存储地图数据
int d[N][N];//存储距离
int n,m,posx1,posy1,posx2,posy2;//传入的行和列数以及起始终止点的位置
PII q[N*N];//数组模拟队列，需要开元素的个数的大小

int bfs(int posx2,int posy2)
{
    int hh=0,tt=0;//队头和队尾指针
    q[0] = {posx1-1,posy1-1};//队列初始化，放入起始位置的坐标

    memset(d,-1,sizeof d);//d初始化为-1，-1表示这个位置还未经过，sizeof(d) = N*N*4,int是个字节，所以乘4
    d[posx1-1][posy1-1] = 0;//起始位置与自己的距离是0

    int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};//四个方向的移动x和y的坐标的变化

    while(hh <= tt)//队列非空
    {
        auto t = q[hh++];//弹出队头元素

        for(int i = 0; i < 4; i++)//四个方向的移动
        {
            int x = t.first + dx[i],y = t.second + dy[i];
            if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == '.' && d[x][y] == -1)//这个点未走过且在边界内且无障碍物
            {
                d[x][y] = d[t.first][t.second] + 1;//这个点与起始位置的点的距离在上一个点的距离上加1
                q[++tt] = {x,y};//从队尾压入新的位置的坐标
            }
            if(d[posx2-1][posy2-1] != -1)//表示到达终止点，返回
            {
                return d[posx2-1][posy2-1];
            }
        }
    }
    return -1;
}
int main()
{
    scanf("%d%d%d%d%d%d",&n,&m,&posx1,&posy1,&posx2,&posy2);
    getchar();
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < m; j++)
        {
            scanf("%c",&g[i][j]);
        }
        getchar();//读取换行符
    }
    printf("%d",bfs(posx2,posy2));
    return 0;
}

3、邻接表存储树和图(邻接表就是单链表 ）

  • 树是特殊的有向图，是无环连通图
  • 无向图也是一种特殊的有向图，是双向的
  • 邻接表的存储代码
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int N = 100010,M = N*2;
int h[N],e[M],ne[M],idx;

/* a：被插入的节点
 * b：新插入的节点，之后有a指向b的边
 */
void add(int a,int b)
{
	e[idx] = b, ne[idx] = h[a],h[a] = idx++;
}
int main()
{
	memset(h,-1,sizeof h);//h数组是图里面的节点，初始都是指向-1，也就是相当于nullptr
}

3.1、深度优先遍历（特殊的深搜）

  • 解析：有向图的遍历，深度遍历，逮住一个起点一直往下递归，每个点只遍历一次，直到结束再回溯再递归，一直遍历完所有的点
    在这里插入图片描述
  • 题目链接：未找到对应的题目，贴上acwing原题
    在这里插入图片描述
  • 题目解析：图中的无向图，可以看到左图删除节点1，有三个连通域，大小分别是3，4，1，最大值为4，我们只需要遍历节点1 的子节点就能得到三个大小。右图删除节点4，三个连通域大小分别为5，2，1，上面连通域的大小我们只要求出节点4的子节点数，用总数减去就能得到。那对应的每删除一个节点都有相应的连通域，要求出这些连通域中最大值中的最小值。
    在这里插入图片描述
  • 代码解析：下面的代码初看是有点绕的，图中举了一个较短的例子遍历，可以先把数组的内容全都列出来，假设从1节点开始：1）dfs(1)，i=h[1]=2，j=e[2]=3；2）dfs(3)，i=h[3]=3，j=e[3]=1，continue；3）i=ne[3]=-1；4）i=ne[2]=0，j=e[0]=2；5）dfs(2)，i=h[2]=6，j=e[6]=5；6）dfs(5)，i=h[5]=7，j=e[7]=2，continue；7）i=ne[7]=-1；8）i=ne[6]=4，j=e[4]=4；9）dfs(4)，i=h[4]=5，j=e[5]=2，continue；10）i=ne[5]=-1；11）i=ne[4]=1，j=e[1]=1，continue；12）i=ne[1]=-1结束。遍历的顺序是1->3->-1再返回1，接着1->2->5->-1再返回2，接着2->4->-1再返回2，2再返回1，1->-1结束遍历。可以看到3的ne保存这到2路径，也就是直接从1到2，中间省去了1。
    在这里插入图片描述
  • 代码（acwing源码）
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010, M = N * 2;//因为需要建立两份边，所以 M = 2 * N;

int n;
int h[N], e[M], ne[M], idx;
int ans = N;
bool st[N];
//添加边的模板，要求熟练的默写，这部分的解释在 链表 专题中
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
//返回以u为根的子树中节点的个数，包括u节点
int dfs(int u)
{
    st[u] = true;

    int size = 0, sum = 0;//size存储的是以u为根的数的一个子儿子的节点数的最大值
    //sun存储以u为根的树的节点数, 包括u
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (st[j]) continue;

        int s = dfs(j);    //s存储的就是以 j 为根的子树的节点数，包括 j
        size = max(size, s);  //每次找出最大的子图的节点数
        sum += s;  //以j为根的树的节点数
    }

    size = max(size, n - sum - 1); //求 dfs 遍历的所有子树中最大的节点数的个数和 dfs 未遍历的那棵树的节点数的最大值
    ans = min(ans, size);

    return sum + 1;   //这里返回的个数加上根节点
}

int main()
{
    scanf("%d", &n);

    memset(h, -1, sizeof h);

    for (int i = 0; i < n - 1; i ++ )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b), add(b, a); //处理无向图的添边方式
    }

    dfs(1); //可以选择任意一个点开始进行 dfs，又u <= n，且 n 的最小值为1，所以只能从 1 开始
			//当然本题数据是从 5 开始的，所以对于本题写 dfs (1 ~ 5)均可AC
    printf("%d\n", ans);

    return 0;
}

3.2、宽度优先遍历（特殊的宽搜）

  • 解析：套用宽度优先搜索的模板，逮住一个点开始，遍历所有的节点，看保存的节点个数是否和输入的相等，相等的话则是全连通的，否则不是
  • 题目链接：宽度优先遍历
  • 代码
#include <iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N = 1010,M = N * 2;//因为无向图需要建立两份边，所以 M = 2 * N;
int e[M],ne[M],h[N];
int n,m,idx;

int bfs()//广度优先遍历
{
    int hh=0,tt=0;//队头和队尾指针
    int q[N];//数组模拟队列
    bool st[N];//是否遍历过标记
    q[0] = 1;//队列初始化，模板步骤
    st[1] = true;//这个元素被遍历过了
    int ret = 0;//保存节点数
    while(hh <= tt)//队列不为空
    {
        int t = q[hh++];//弹出队头
        for(int i = h[t]; i != -1; i = ne[i])//按照边去遍历
        {
            int j = e[i];
            if(st[j])
                continue;
            else
                st[j] = true,ret++,q[++tt] = j;//该节点未被遍历过，则压进队尾，标记被遍历，节点数加1
        }
    }
    return ret+1;//因为开始的节点本身没被算进去，需要加1
}
void add(int x,int y)//无向图的建立，前面已经解释过了
{
    e[idx] = y,ne[idx] = h[x],h[x] = idx++;
}

int main() {
    memset(h,-1,sizeof h);
    while(cin >> n >> m)
    {
        if(!n && !m)
            break;
        while(m--)
        {
            int x,y;
            cin >> x >> y;
            add(x,y),add(y,x);//建立双边
        }
        if(bfs()==n)
        {
            cout << "YES" << endl;
            memset(h,-1,sizeof h);//因为输入是有很多图的，处理完一个无序图需要重新清空准备处理下一个无序图
            memset(e,0,sizeof e);
            memset(ne,0,sizeof ne);
            idx = 0;
        }
        else
        {
            cout << "NO" << endl;
            memset(h,-1,sizeof h);
            memset(e,0,sizeof e);
            memset(ne,0,sizeof ne);
            idx = 0;
        }
    }
}

3.3、有向图的拓扑序列(有环的有向图不可能是拓扑序列)

  • 入度：一个点有多少指向自己的边
  • 出度：一个点有多少边从自己这出去
  • 解析：当一个图按拓扑序排好之后，起点一定是在终点的前面，如图中所示，当按1，2，3排序就是一个拓扑序列，所有边的起点都在终点的前面。当求解一个有向图是否能够组成拓扑排序的时候，也就是看看能否将所有的节点的入度都处理为0，能的话就能拓扑排序，否则就不能
    在这里插入图片描述
  • 题目连接：拓扑排序
  • 代码
#include <iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N = 200010;

int e[N],ne[N],h[N];
int d[N];
int n,m,idx;
int q[N];//宽搜的模板队列

void add(int x,int y)//图的构建
{
    e[idx] = y,ne[idx] = h[x],h[x] = idx++;
}

bool tuposort()//拓扑排序
{
    int hh = 0,tt = -1;
    for(int i =1; i <= n; i++)
    {
        if(!d[i])
            q[++tt] = i;//首先把所有入度为0的点压入队列
    }
    while(hh <= tt)//宽搜模板
    {
        int t = q[hh++];//弹出队头，元素还在数组里面，只是用了头尾指针来表示弹出与压入
        for(int i = h[t]; i != -1; i = ne[i])//宽搜遍历，这个是有向图，不会重复遍历
        {
            int j = e[i];
            d[j]--;//该节点的入度减1
            if(d[j] == 0)
                q[++tt] = j;//该节点入度变为0之后就压入队列
        }
    }
    return tt == n-1;//所有的点都能够被入队说明是一个有向无环图，即能构成拓扑排序
}

int main() {
    memset(h,-1,sizeof h);
    scanf("%d%d",&n,&m);
    while(m--)
    {
        int x,y;
        cin >> x >> y;
        add(x,y);
        d[y]++;//保存这个点的入度
    }
    if(tuposort())
    {
        for(int i = 0; i < n; i++)
        {
            if(i!=n-1)
                printf("%d ",q[i]);
            else  
                printf("%d",q[i]);//答案最后有一个数不能有空格，有空格提交不成功
        }
    }
    else {
        printf("%d",-1);//无拓扑排序输出-1
    }
}

4、最短路

4.1、单源最短路

  • 求一个点到其他所有点的最短路

4.1.1、所有边权都是整数

  • 朴素Dijkstra：稠密图（邻接矩阵），m(边数)~n^2(点数)
    • 模板：
      • 1.dist[1] = 0，dist[i] = 正无穷
      • 2.for i 1~n(迭代)
        • t<-不在s中的，距离最近的点
        • s<-t；//s是当前已确定最短距离的点
        • 用t更新其他点的距离
    • 题目链接：Dijkstra求最短路径
    • 代码
class Solution {
public:
    int networkDelayTime(vector<vector<int>> &times, int n, int k) {
        const int inf = INT_MAX/2;
        
        //构建邻接矩阵
        int g[n][n];
        memset(g,0x3f3f3f3f,sizeof g);//这里初始化后的值不等于inf
        for(auto &t:times)
        {
            int x = t[0]-1,y = t[1]-1;
            g[x][y] = min(g[x][y],t[2]);
        }
-		
-		//存储距离的数组，初始化为g数组一样的最大值
        vector<int>dist(n,0x3f3f3f3f);//保存距离
        dist[k-1] = 0;//k是出发点，将出发点的距离设为0，数组中的坐标与节点值是-1的关系
        vector<int> st(n,0);//保存是否遍历过的标记
        for(int i = 0; i < n;i++)//这个循环是遍历n个节点
        {
            int t = -1;
            for(int j = 0; j < n; j++)//这个循环是找到出发点
            {
                if(!st[j] && (t == -1 || dist[j] < dist[t]))
                {
                    t = j;
                }
            }

            st[t] = true;//标记这个点被遍历了

            for(int j = 0; j < n; j++)//这个循环是计算出出发点最到他点的最短距离
            {
                dist[j] = min(dist[j],dist[t] + g[t][j]);
            }
        }
        int ans = *max_element(dist.begin(),dist.end());
        return ans == 0x3f3f3f3f ? -1 : ans;
    }
};
  • 堆优化版的Dijkstra算法：稀疏图（邻接表），m(边数)~n(点数)
    • 解析：堆优化版的改进是在朴素版的基础上，在for循环找到目标最近点用堆来替代，从而减小时间复杂度，题意中可以看到n和m的数量级是相等的，因此是稀疏图，用邻接表来做
    • 题目链接：未找到，acwing原题
      在这里插入图片描述
    • 代码
#include <iostream>
#include <algorithm>
#include <cstring>
#include<vector>
#include<queue>

using namespace std;

typedef pair<int,int>PII;

const int N = 1e6+10;

int n,m;
int h[N],w[N],e[N],ne[N],idx;
int dist[N];
bool st[N];

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

int dijkstra()
{
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;//优先队列定义一个小根堆
    heap.push({0,1});//整个代码就是邻接表加宽搜模板，初始化队列
    while(heap.size())
    {
        auto t = heap.top();//取出队头
        heap.pop();//弹出队头

        int ver = t.second,distance = t.first;

        if(st[ver])continue;//是否已经遍历过

        for(int i = h[ver]; i != -1; i = ne[i])//最短路径替换
        {
            int j = e[i];
            if(dist[j] > dist[ver] + w[i])
            {
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j],j});
            }
        }
    }
    if(dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

int main()
{
    scanf("%d%d",&n,&m);

    memset(h,-1,sizeof h);
    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);//添加有向边
    }

    printf("%d\n",dijkstra());

    return 0;
}

4.1.2、存在负权边

  • Bellman-Ford算法
    • 模板
      • for n 次
        • for 所有边a，b，w
          • dist[b] = min(dist[b],dist[a]+w)
    • 题目链接：bellman-ford模板算法
    • 代码
class Solution {
public:
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
        int m = flights.size();//写成int m = flights.size()+10; int dist[m],backup[m];会报错
        int dist[m+10],backup[m+10];//为了防止超出数组界限，所以在长度上加10

        memset(dist,0x3f,sizeof dist);
        dist[src] = 0;//从哪个点开始，那个点起始的距离为0
        for(int i = 0; i < k+1; i++)//这里k是中转站点，而不是边数，所以是k+1，因为得加上起点
        {
            memcpy(backup,dist,sizeof dist);//加备份，防止出现串联
            for(int j = 0; j < m; j++)
            {
                auto t = flights[j];
                dist[t[1]] = min(dist[t[1]],backup[t[0]] + t[2]);//防止串联，因为要满足k的限制，所以必须保证不能用这次的更新去更新后面的距离
            }
        }
        if(dist[dst] > 0x3f3f3f3f/2) return -1;
        else return dist[dst];
    }
};
  • SPFA算法
    • 使用宽搜的队列对Dellman-Ford算法的改进
    • 使用SPFA判断负环，也能用于Dijkstra算法解决的最短路径问题
      • 题目链接：判断负环
#include <iostream>
#include <queue>
#include <cstring>

using namespace std;

const int N = 210,M = 2010;
int n,m,a,b,c;
int h[N],e[M],ne[M],w[M],idx;
int dist[N],cnt[N];
bool st[N];

//使用邻接表构建图
void add(int a,int b,int c)
{
    e[idx] = b,w[idx] = c,ne[idx] = h[a],h[a] = idx++;
}

bool spfa()
{
    queue<int>q;
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;//因为能到达的话是输出从1号点到n号点的距离，所以1号点的距离初始化为0
    for(int i = 1; i <= n; i++)
    {
        st[i] = true;
        q.push(i);//先把所有的点入队列
    }

    while(q.size())
    {
        int t = q.front();
        q.pop();
        st[t] = false;

        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(dist[j] > dist[t] + w[i])//这个条件保证了是负边环
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;

                if(cnt[j] >= n) return true;//cnt里面存的是边数，如果边数大等于n，那么点数大等于n+1，因为只有n个点，所以一定是有环的
                if(!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    return false;
}

int main() {

    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    if(spfa())
    	puts("circle");
    else
    {
        if(dist[n] == 0x3f3f3f3f) 
        	puts("can't arrive!");
        else
            cout << dist[n];
    }
}

4.2、多源汇最短路

  • 源：起点；汇：终点
  • 任选两个点，求这两个点之间的最短路
  • Floyd算法
    • 模板，用邻接矩阵存储边
      • d[i,j]
        • for(k=1;k<=n;k++)
          • for(i=1; i<=m; i++)
            • for(j=1; j<=n; j++)
              • d[i,j] = min(d[i,j],d[i,j] + d[k,j]);//使用了动态规划的原理
    • 题目链接：Floyd算法
    • 代码
在这里插入代码片

5、最小生成树

5.1、prim算法

  • 朴素版：稠密图

    • 模板
      • dist[i]<-inf
      • for(i=0;i<n;i++)
        • t<-找到集合外距离最近的点
        • 用t更新其他点到集合的距离
        • st[t] = true;

  • 解析：起始每个点存储的距离初始化都是inf，随后随便找到一个点开始，图中从1开始，用1到其他点的距离去更新各个点存储的距离，然后1被放入集合
    在这里插入图片描述

  • 堆优化版（一般不用）

5.2、Kruskal算法（稀疏图）

6、二分图

6.1、染色法

6.2、匈牙利算法

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

使用 Netty 实现群聊功能的步骤和注意事项

使用 Netty 实现群聊功能的步骤和注意事项

文章目录 前言声明功能说明实现步骤WebSocket 服务启动Channel 初始化HTTP 请求处理HTTP 页面内容WebSocket 请求处理 效果展示总结 前言 通过之前的文章介绍&#xff0c;我们可以深刻认识到Netty在网络编程领域的卓越表现和强大实力。这篇文章将介绍如何利用 Netty 框架开发一…
阅读更多...
QT登陆注册界面练习

QT登陆注册界面练习

一、界面展示 二、主要功能界面代码 #include "widget.h" #include "ui_widget.h"Widget::Widget(QWidget *parent): QMainWindow(parent), ui(new Ui::Widget) {ui->setupUi(this);this->setFixedSize(540,410); //设置固定尺寸th…
阅读更多...
【计算机组成 课程笔记】2.1 设计自己的计算机

【计算机组成 课程笔记】2.1 设计自己的计算机

课程链接&#xff1a; 计算机组成_北京大学_中国大学MOOC(慕课) 2 - 1 - 201-设计自己的计算机&#xff08;14‘24’‘&#xff09;_哔哩哔哩_bilibili 什么是指令系统体系结构&#xff1f;这个问题其实非常简单&#xff0c;但要想解释清楚也没有那么容易。我们还是从一个小故事…
阅读更多...
兄弟 Goland 咱能一次性将注释设置好不

兄弟 Goland 咱能一次性将注释设置好不

大家好&#xff0c;我是阿兵云原生 工作中我们都只是写注释是一个好习惯&#xff0c;作为新生代的农名工&#xff0c;特别烦的就是别人不写注释&#xff0c;但是自己偏偏又不喜欢写注释&#x1f602;&#x1f602;&#x1f602; 对于 golang 的注释&#xff0c;我发现很多新朋…
阅读更多...
攻防世界-What-is-this

攻防世界-What-is-this

原题 解题思路 解压后文件 没有后缀&#xff0c;不知道是什么文件。用notepad打开找不到flag。 尝试当成压缩包解压。 用stegsolve以打开图片1&#xff0c; 合成两张图片。
阅读更多...
MySQL中的表与视图：解密数据库世界的基石

MySQL中的表与视图：解密数据库世界的基石

&#x1f3c6;作者简介&#xff0c;黑夜开发者&#xff0c;CSDN领军人物&#xff0c;全栈领域优质创作者✌&#xff0c;CSDN博客专家&#xff0c;阿里云社区专家博主&#xff0c;2023年6月CSDN上海赛道top4。 &#x1f3c6;数年电商行业从业经验&#xff0c;历任核心研发工程师…
阅读更多...
vue中axios请求篇

vue中axios请求篇

vue中如何发起请求? 利用axios来发起请求&#xff0c;但是前期需要配置 首先安装axios 可以使用npm、yarn等进行安装 npm安装方式 npm install axios -sava //在项目文件夹中打开cmd或者终端进行安装依赖 yarn安装方式 yarn add axios 引入axios。我一般是在src下创建一个u…
阅读更多...
【C++】学习C++STL中的数组——vector

【C++】学习C++STL中的数组——vector

❤️前言 好久不见大家&#xff01;今天的这篇博客是关于我对于STL(C标准模板库)中的容器vector的学习和理解&#xff0c;希望大家能够喜欢。 正文 vector是STL中的一种序列容器&#xff0c;对应着数据结构中的顺序表&#xff0c;也可以说是数组。在我们正式学习了解vector之前…
阅读更多...
spring boot 测试用例

spring boot 测试用例

依赖包 <dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.2.5.RELEASE</version><scope>compile</scope></dependency><dependency><groupId>ju…
阅读更多...
Autoware.universe部署05：实车调试

Autoware.universe部署05：实车调试

文章目录 一、建图1.1 点云地图1.2 高精地图 二、参数配置三、传感器数据通信接口3.1 雷达点云3.2 图像3.3 IMU3.4 GNSS RTK 四、实车调试4.1 编写启动4.2 修改传感器外参4.3 修改车身参数4.4 实车调试 本文介绍了 Autoware.universe 在实车上的部署&#xff0c;本系列其他文章…
阅读更多...
《Web安全基础》04. 文件上传漏洞

《Web安全基础》04. 文件上传漏洞

web 1&#xff1a;文件上传漏洞2&#xff1a;WAF 绕过2.1&#xff1a;数据溢出2.2&#xff1a;符号变异2.3&#xff1a;数据截断2.4&#xff1a;重复数据 本系列侧重方法论&#xff0c;各工具只是实现目标的载体。 命令与工具只做简单介绍&#xff0c;其使用另见《安全工具录》…
阅读更多...
2023京东口腔护理赛道行业数据分析（京东销售数据分析）

2023京东口腔护理赛道行业数据分析（京东销售数据分析）

近年来&#xff0c;口腔护理逐渐成为年轻人重视的健康领域&#xff0c;从口腔护理整体市场来看&#xff0c;牙膏和牙刷等基础口腔护理产品仍占据主导地位。不过&#xff0c;随着口腔护理市场逐步朝向精致化、专业化、多元化等方向发展&#xff0c;不少新兴口腔护理产品受到消费…
阅读更多...
C++学习|CUDA内存管理代码实例

C++学习|CUDA内存管理代码实例

前言&#xff1a;之前介绍了CUDA入门知识&#xff0c;对CUDA编程有了一个基本了解&#xff0c;但是实际写起来还是遇到很多问题&#xff0c;例如cpp文件该怎么调用cuda文件、cpu和gpu之间内存数据怎么交换、如何编写.cu和.cuh文件之类的。本篇文章将会以一个实现向量相加的代码…
阅读更多...
【数据结构】二叉数的存储与基本操作的实现

【数据结构】二叉数的存储与基本操作的实现

文章目录 &#x1f340;二叉树的存储&#x1f333;二叉树的基本操作&#x1f431;‍&#x1f464;二叉树的创建&#x1f431;‍&#x1f453;二叉树的遍历&#x1f3a1;前中后序遍历&#x1f4cc;前序遍历&#x1f4cc;中序遍历&#x1f4cc;后续遍历 &#x1f6eb;层序遍历&am…
阅读更多...
什么是Python爬虫分布式架构，可能遇到哪些问题，如何解决

什么是Python爬虫分布式架构，可能遇到哪些问题，如何解决

目录 什么是Python爬虫分布式架构 1. 调度中心&#xff08;Scheduler&#xff09;&#xff1a; 2. 爬虫节点&#xff08;Crawler Node&#xff09;&#xff1a; 3. 数据存储&#xff08;Data Storage&#xff09;&#xff1a; 4. 反爬虫处理&#xff08;Anti-Scraping&…
阅读更多...
2023-08-30力扣每日一题

2023-08-30力扣每日一题

链接&#xff1a; 1654. 到家的最少跳跃次数 题意&#xff1a; 从0出发&#xff0c;到X的最少步数 它可以 往前 跳恰好 a 个位置&#xff08;即往右跳&#xff09;。它可以 往后 跳恰好 b 个位置&#xff08;即往左跳&#xff09;。它不能 连续 往后跳 2 次。它不能跳到任何…
阅读更多...
2023新版医保目录明细（药品查询）

2023新版医保目录明细（药品查询）

查询医保目录的主要目的是为了了解医保政策对于特定医疗服务、药品和医疗器械的覆盖范围和支付标准。大众可以通过查看医保目录可以确定哪些药品可以被医保支付以及报销的比例和限额&#xff1b;医药从业者可通过查看医保目录可以即使了解医保政策的变化&#xff0c;便于做出相…
阅读更多...
Window10 安装 Lua

Window10 安装 Lua

1、下载地址&#xff1a;https://luabinaries.sourceforge.net/download.html 2、下载 3、解压后共有4个文件&#xff0c;这里我把这几个文件放到如下目录 D:\Program Files\lua-5.4.2\bin 4、定义环境变量 5、打开 powershell&#xff0c;运行 lua54 -v PS C:\Windows\syste…
阅读更多...
qt设计界面

qt设计界面

widget.h #ifndef WIDGET_H #define WIDGET_H //防止文件重复包含#include <QWidget> //QWidget类所在的头文件&#xff0c;父类头文件 #include<QIcon> #include<QPushButton> …
阅读更多...
Facebook Shops免费面世 Facebook与Instagram携手并肩

Facebook Shops免费面世 Facebook与Instagram携手并肩

图片来源&#xff1a;SaleSmartly官网 近年来网上购物剧增&#xff0c;电子商务越趋重要&#xff0c;Facebook 和Instragram乘势推出Facebook Shops&#xff0c;免费让零售商户在全球最多使用者的两个社交平台创建线上商户&#xff0c;展示产品和进行交易&#xff0c;助零售业走…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023