kuangbin 最小生成树

最新推荐文章于 2024-07-13 21:34:41 发布
最新推荐文章于 2024-07-13 21:34:41 发布
阅读量99 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/smallhester/p/10403095.html
版权

A & M - Jungle Roads HDU - 1301 

题意：字母之间的路，求最小生成树

题解：处理好建边以后就是一个Prime

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include <set>
#include<queue>
#include<map>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn =  50;
const ll mod = 1e9+7;
const double eps = 1e-8;

bool vis[maxn];
int lowc[maxn];

int Prim(int cost[][maxn],int n)
{
    int ans = 0;
    memset(vis,false,sizeof vis);
    vis[0] = true;
    for(int i=1;i<n;i++)
        lowc[i] = cost[0][i];
    for(int i=1;i<n;i++)
    {
        int minc = INF;
        int p = -1;
        for(int j=0;j<n;j++)
        {
            if(!vis[j] && minc > lowc[j])
            {
                minc = lowc[j];
                p = j;
            }
        }
        if(minc == INF)
            return -1;
        ans += minc;
        vis[p] = true;
        for(int j=0;j<n;j++)
            if(!vis[j] && lowc[j] > cost[p][j])
                lowc[j] = cost[p][j];
    }
    return ans;
}
int main()
{
    int n;
    while(scanf("%d",&n) && n)
    {
        int cost[maxn][maxn];
        for(int i=0;i<maxn;i++)
        {
            for(int j=0;j<maxn;j++)
                if(i == j)
                    cost[i][j] = 0;
                else
                    cost[i][j] = INF;
        }
        for(int i=1;i<n;i++)
        {
            char a;
            cin>>a;
            int num;
            cin>>num;
            for(int i=0;i<num;i++)
            {
                char ch;
                int len;
                cin>>ch>>len;
                cost[a-'A'][ch-'A'] = len;
                cost[ch-'A'][a-'A'] = len;
            }
        }

        int ans = Prim(cost,n);
        cout<<ans<<endl;
    }

}
View Code

 

B - Networking POJ - 1287 

题意：有重复边的跑最小生成树

题解：边取小跑Prime

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include <set>
#include<queue>

using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn = 1e2+5;
bool vis[maxn];
int lowc[maxn];
int Prim(int cost[][maxn],int n)
{
    int ans = 0;
    memset(vis,false,sizeof vis);
    vis[1] = true;
    for(int i=2;i<=n;i++)
        lowc[i] = cost[1][i];
    for(int i=2;i<=n;i++)
    {
        int minc = INF;
        int p = -1;
        for(int j=1;j<=n;j++)
            if(!vis[j] && minc > lowc[j])
            {
                minc = lowc[j];
                p = j;
            }
        if(minc == INF)
            return -1;
        ans += minc;
        vis[p] = true;
        for(int j=1;j<=n;j++)
            if(!vis[j] && lowc[j] > cost[p][j])
                lowc[j] = cost[p][j];
    }
    return ans;

}
int main()
{
    int n,m;
    while(scanf("%d",&n) && n)
    {
        scanf("%d",&m);
        int cost[maxn][maxn];
        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] = INF;
        for(int i=0;i<m;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            cost[a][b] = min(cost[a][b],c);
            cost[b][a] = min(cost[b][a],c);
            cost[a][b] = cost[b][a] = min(cost[a][b],cost[b][a]);
        }
        int ans = Prim(cost,n);
        printf("%d\n",ans);
    }
}
View Code

 

C - Building a Space Station POJ - 2031

题意：三维上的球上建最小生成树

题解：处理边即可

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include <set>
#include<queue>

using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn = 1e2+5;

struct node
{
    double x,y,z,r;
}a[maxn];
double dis(double x1,double y1,double z1,double r1,double x2,double y2,double z2,double r2)
{
    double len = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) + (z1-z2)*(z1-z2);
    double ans = sqrt(len) - r1 - r2;
    return max(0.0,ans);
}
bool vis[maxn];
double lowc[maxn];
double Prime(double cost[][maxn],int n)
{
    double ans = 0;
    memset(vis,0,sizeof vis);
    vis[0] = true;
    for(int i=1;i<n;i++)
        lowc[i] = cost[0][i];
    for(int i=1;i<n;i++)
    {
        double minc = 9999999999.9;
        int p = -1;
        for(int j=0;j<n;j++)
            if(!vis[j] && minc > lowc[j])
            {
                p = j;
                minc = lowc[j];
            }
        ans += minc;
        vis[p] = true;
        for(int j=0;j<n;j++)
            if(!vis[j] && lowc[j] > cost[p][j])
                lowc[j] = cost[p][j];
    }
    return ans;
}
int main()
{
    int n;
    while(scanf("%d",&n) && n)
    {
        double cost[maxn][maxn];
        for(int i=0;i<n;i++)
            scanf("%lf %lf %lf %lf",&a[i].x,&a[i].y,&a[i].z,&a[i].r);
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                cost[i][j] = dis(a[i].x,a[i].y,a[i].z,a[i].r,a[j].x,a[j].y,a[j].z,a[j].r);
        double ans = Prime(cost,n);
        printf("%.3f\n",ans);
    }
}
View Code

 

D - Constructing Roads POJ - 2421 

题意：邻接矩阵有些边权值为0，求最小生成树

题解：Prim

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include <set>
#include<queue>

using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn = 1e2+5;

int vis[maxn];
int lowc[maxn];
int cost[maxn][maxn];

int Prim(int cost[][maxn],int n)
{
    int ans = 0;
    memset(vis,0,sizeof vis);
    vis[1] = true;
    for(int i=2;i<=n;i++)
        lowc[i] = cost[1][i];
    for(int i=2;i<=n;i++)
    {
        int minc = INF;
        int p = -1;
        for(int j=1;j<=n;j++)
            if(!vis[j] && minc > lowc[j])
            {
                minc = lowc[j];
                p = j;
            }
        ans += minc;
        vis[p] = true;
        for(int j=1;j<=n;j++)
            if(!vis[j] && lowc[j] > cost[p][j])
                lowc[j] = cost[p][j];
    }
    return ans;
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            scanf("%d",&cost[i][j]);
    int q;
    scanf("%d",&q);
    for(int i=0;i<q;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        cost[a][b] = cost[b][a] = 0;
    }
    int ans = Prim(cost,n);
    printf("%d\n",ans);
}
View Code

 

 E - QS Network ZOJ - 1586 

题意：最小生出树，边的值还需要加上两个顶点的值

题解：只需要将顶点的值加到其权值上即可

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include <set>
#include<queue>

using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn = 1e3+5;

bool vis[maxn];
int lowc[maxn];
int cost[maxn][maxn];
int a[maxn];
int prim(int cost[][maxn],int n)
{
    int ans = 0 ;
    memset(vis,false,sizeof vis);
    vis[1] = true;
    for(int i=2;i<=n;i++)
        lowc[i] = cost[1][i];
    for(int i=2;i<=n;i++)
    {
        int minc = INF;
        int p = -1;
        for(int j=1;j<=n;j++)
        {
            if(!vis[j] && minc > lowc[j])
            {
                minc = lowc[j];
                p = j;
            }
        }
        ans += minc;
        vis[p] = true;
        for(int j=1;j<=n;j++)
            if(!vis[j] && lowc[j] > cost[p][j])
                lowc[j] = cost[p][j];
    }
    return ans;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        int ans = 0;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++) {
                scanf("%d", &cost[i][j]);
                cost[i][j] += a[i] + a[j];
            }
        ans += prim(cost,n);
        printf("%d\n",ans);
    }
}
View Code

 

F - Truck History POJ - 1789 

题意：两个字符串之间不同的个数为边的权值，跑最小生成树

题解：处理边之后跑最小生成树

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include <set>
#include<queue>

using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn = 2e3+5;

bool vis[maxn];
int lowc[maxn];
int cost[maxn][maxn];
int a[maxn];
int prim(int cost[][maxn],int n)
{
    int ans = 0 ;
    memset(vis,false,sizeof vis);
    vis[1] = true;
    for(int i=2;i<=n;i++)
        lowc[i] = cost[1][i];
    for(int i=2;i<=n;i++)
    {
        int minc = INF;
        int p = -1;
        for(int j=1;j<=n;j++)
        {
            if(!vis[j] && minc > lowc[j])
            {
                minc = lowc[j];
                p = j;
            }
        }
        ans += minc;
        vis[p] = true;
        for(int j=1;j<=n;j++)
            if(!vis[j] && lowc[j] > cost[p][j])
                lowc[j] = cost[p][j];
    }
    return ans;
}
int main()
{
    int n;
    while(scanf("%d",&n) && n)
    {
        char str[maxn][10];
        for(int i=1;i<=n;i++)
            scanf("%s",str[i]);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            {
                int tmp = 0;
                for(int k=0;k<7;k++)
                    if(str[i][k] != str[j][k])
                        tmp++;
                cost[i][j]  = cost[j][i] = tmp;
            }
        int ans  = prim(cost,n);
        printf("The highest possible quality is 1/%d.\n",ans);
    }
}
View Code

 

 J - Borg Maze POJ - 3026 

题意：迷宫之中的MST

题解：先bfs预处理，之后在进行MST，输入的时候有坑点，wa了好几次

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include <set>
#include<queue>

using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn = 550;
int tree[maxn][maxn],id[maxn][maxn],dis[maxn][maxn],n,m,tot;
bool vis[maxn][maxn];
int lowc[maxn],visit[maxn];
char mp[maxn][maxn];
int dx[] = {0,1,0,-1};
int dy[] = {1,0,-1,0};
struct node
{
    int x,y;
};
bool check(int x,int y)
{
    if(x >= 1 && x <= n && y >= 1 && y <= m && !vis[x][y] && mp[x][y] != '#')
        return true;
    return false;
}
void bfs(int x,int y)
{
    memset(vis,false,sizeof vis);
    memset(dis,0,sizeof dis);
    queue<node>que;
    node temp;
    temp.x = x;
    temp.y = y;
    que.push(temp);
    vis[x][y] = true;
    while(!que.empty())
    {
        temp = que.front();
        que.pop();
        for(int i=0;i<4;i++)
        {
            int nx = temp.x + dx[i];
            int ny = temp.y + dy[i];
            if(check(nx,ny))
            {
                vis[nx][ny] = true;
                dis[nx][ny] = dis[temp.x][temp.y] + 1;
                if(mp[nx][ny] == 'A' || mp[nx][ny] == 'S')
                    tree[id[x][y]][id[nx][ny]] = tree[id[nx][ny]][id[x][y]] = dis[nx][ny];
                que.push(node{nx,ny});
            }
        }
    }
}

int Prime(int cost[][maxn],int n)
{
    int ans = 0;
    memset(visit,false,sizeof visit);
    visit[1] = true;
    for(int i=2;i<=n;i++)
        lowc[i] = cost[1][i];
    for(int i=2;i<=n;i++)
    {
        int minc = INF;
        int p = -1;
        for(int j=1;j<=n;j++)
            if(!visit[j] && minc > lowc[j])
            {
                minc = lowc[j];
                p = j;
            }
        ans += minc;
        visit[p] = true;
        for(int j=1;j<=n;j++)
            if(!visit[j] && lowc[j] > cost[p][j])
                lowc[j] = cost[p][j];
    }
    return ans;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int tot = 0;
        scanf("%d%d ",&m,&n);
        for(int i=1;i<=n;i++)
            gets(mp[i] + 1);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if(mp[i][j] == 'A' || mp[i][j] == 'S')
                    id[i][j] = ++tot;
        for(int i=1;i<=tot;i++)
            for(int j=1;j<=tot;j++)
                if(i == j)
                    tree[i][j] = 0;
                else
                    tree[i][j] = INF;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if(mp[i][j] == 'A' || mp[i][j] == 'S')
                    bfs(i,j);
        int ans = Prime(tree,tot);
        printf("%d\n",ans);
    }
}
View Code

 

L - 还是畅通工程 HDU - 1233 

题意：直接就是求最小生成树了

题解：板子

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include <set>
#include<queue>
#include<map>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn =  1005;
const ll mod = 1e9+7;
const double eps = 1e-8;

int lowc[maxn];
bool vis[maxn];

int Prime(int cost[][maxn],int n)
{
    int ans = 0;
    memset(vis,false,sizeof vis);
    vis[0] = true;
    for(int i=1;i<n;i++)
        lowc[i] = cost[0][i];
    for(int i=1;i<n;i++)
    {
        int minc = INF;
        int p = -1;
        for(int j=0;j<n;j++)
        {
            if(!vis[j] && minc > lowc[j])
            {
                minc = lowc[j];
                p = j;
            }
        }
        if(minc == INF)
            return -1;
        ans += minc;
        vis[p] = true;
        for(int j=0;j<n;j++)
            if(!vis[j] && lowc[j] > cost[p][j])
                lowc[j] = cost[p][j];
    }
    return ans;
}
int main()
{
        int n;
        while(scanf("%d",&n) && n)
        {
            int cost[maxn][maxn];
            memset(cost,0,sizeof cost);
            for (int i = 0; i < n * (n - 1) / 2; i++)
            {
                int a, b, l;
                scanf("%d%d%d", &a, &b, &l);
                cost[a-1][b-1] = l;
                cost[b-1][a-1] = l;
            }

            int ans = Prime(cost, n);
            printf("%d\n", ans);
        }
}
View Code

 

N - 畅通工程再续 HDU - 1875 

题意：岛之间造桥，只有长度在10～1000才可以造，问最少的花费，花费是桥的长度*100

题解：INF值的判定，INF是长度小于10或者长度大于1000，其余就是Prime的板子

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include <set>
#include<queue>
#include<map>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 99999999999.9
#define PI acos(-1.0)
const int maxn =  1005;
const ll mod = 1e9+7;
const double eps = 1e-8;

double lowc[maxn];
bool vis[maxn];
double dis(int x1,int y1,int x2,int y2)
{
    double ans = sqrt((double)(x2-x1)*(x2-x1)*1.0 + (y2-y1)*(y2-y1)*1.0);
    //cout<<ans<<endl;
    return ans;
}
bool check(double x)
{
    //cout<<x<<endl;
    if(x>=10.0 && x<=1000.0)
        return true;
    else
        return false;
}
double Prime(double cost[][maxn],int n)
{
    double ans = 0;
    memset(vis,false,sizeof vis);
    vis[0] = true;
    for(int i=1;i<n;i++)
        lowc[i] = cost[0][i];
    for(int i=1;i<n;i++)
    {
        double minc = INF;
        int p = -1;
        for(int j=0;j<n;j++)
        {
            if(!vis[j] && minc > lowc[j])
            {
                minc = lowc[j];
                p = j;
            }
        }
        if(minc == INF)
            return -1;
        ans += minc;
        vis[p] = true;
        for(int j=0;j<n;j++)
            if(!vis[j] && lowc[j] > cost[p][j])
                lowc[j] = cost[p][j];
    }
    return ans;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        scanf("%d",&n);
        int x[maxn];
        int y[maxn];
        double cost[maxn][maxn];
        for(int i=0;i<n;i++)
            scanf("%d %d",&x[i],&y[i]);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(i == j) {
                    cost[i][j] = 0;
                    continue;
                }
                else if(check(dis(x[i],y[i],x[j],y[j]))) {
                    //cout<<dis(x[i], y[i], x[j], y[j])<<endl;
                    cost[i][j] = dis(x[i], y[i], x[j], y[j]);
                    cost[j][i] = dis(x[i], y[i], x[j], y[j]);
                }
                else if(!check(dis(x[i],y[i],x[j],y[j])))
                    cost[i][j] = INF;
            }
        }

        //cout<<cost[0][1]<<endl;
        double ans = Prime(cost,n);
        if(ans == -1)
            puts("oh!");
        else
            printf("%.1f\n",ans * 100);
    }
}
View Code

 

转载于:https://www.cnblogs.com/smallhester/p/10403095.html

weixin_30700977
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
最小生成树
muxi@Achilles的专栏
09-05 678
prime模板 核心代码： for(j = 1; j    {     if(lowcost[j] != 0 && lowcost[j] > dis[choose] [j] )  //在这里第一条找到的边是6，那么此时的choose是2，这里的意思就是： //原点到某一点的距离大于被标记的这一点到其余一点的距离，即使说，原点到这些点都可以更新 //也就是相当于找到2后，然后再更新的
kuangbin最小生成树专题
weixin_30713953的博客
11-16 116
网址：https://vjudge.net/contest/66965#overview 第一题： poj1251 裸最小生成树 #include<iostream> #include<algorithm> #include<cstring> using namespace std; const int maxn=100500; struc...
Kuangbin Flying 6最小生成树专题
ACdream
01-29 4386
kuangbin带你飞系列专题六最小生成树题解报告
kuangbin 模板
09-08
kuangbin 模板
kuangbin的ACM模板（2018.7更新）
07-25
kuangbin说他之前的老模板有一些错误，然后这个月分享给了我们新的模板。本来这个东西是公开的免费的，但是上传资源积分至少1个，不支持免费分享。大家如果没有积分的话可以给我私信，我不忙的时候一定会发的~~~欢迎...
kuangbin的ACM模板（新）_模板_kuangbin_kuangbinacm_ACM_
09-29
在ACM竞赛中，图论问题常见于最小生成树（如Prim算法或Kruskal算法）、最短路径（Dijkstra算法、Floyd-Warshall算法等）、强连通分量识别、寻找桥和割点等。这些概念和算法对于解决复杂网络问题有着至关重要的作用。...
kuangbin的ACM模板（新）.pdf
11-15
Contents 1 字符串处理 5 1.1 KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.2 e-KMP . . . . . . . . . . . . . . . . . . . . . . . . . . ....
kuangbin的ACM模板（新）.zip_kuangbin ACM算法模板
09-19
1. **基础数据结构**：线性结构（如数组、链表）、树结构（如二叉树、平衡树）、图结构（如邻接矩阵、邻接表）等。这些数据结构在ACM比赛中常常被用来处理问题，例如搜索、排序、最短路径等。 2. **排序与查找算法*...
7.10飞书一面面经
东篱君的博客
07-10 1184
B+树的⾮叶⼦节点不存放实际的记录数据，仅存放索引，所以数据量相同的情况下，相⽐存储即存索引⼜存记录的 B 树，B+树的⾮叶⼦节点可以存放更多的索引，因此 B+ 树可以⽐ B 树更「矮胖」，查询底层节点的磁盘 I/O次数会更少。主从复制：单节点Redis的并发能力是有上限的，要进一步提高Redis的并发能力，可以搭建主从集群，实现读写分离。B+ 树有⼤量的冗余节点（所有⾮叶⼦节点都是冗余索引），这些冗余索引让 B+ 树在插⼊、删除的效率都更⾼，⽐如删除根节点的时候，不会像 B 树那样会发⽣复杂的树的变化；
[高频 SQL 50 题(基础版)]第一千七百五十七题，可回收且低脂产品
weixin_45201305的博客
07-10 287
low_fats 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品是低脂产品，'N' 表示不是低脂产品。recyclable 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品可回收，而 'N' 表示不可回收。没什么难度，作为基础题五十题的第一题练手，现在也开始陆续写一些SQL，作为记录，和leetcode一起，大家都加油。编写解决方案找出既是低脂又是可回收的产品编号。是该表的主键（具有唯一值的列）。
leetcode--验证二叉搜索树
liulanba的博客
07-09 671
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：节点的左子树只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1：输入：root = [2,1,3]输出：true示例 2：输入：root = [5,1,4,null,null,3,6]输出：false解释：根节点的值是 5 ，但是右子节点的值是 4。提示：树中节点数目范围在[1, 104] 内。
Redis数据结构-String篇
时间如瑾 代码如诗
07-12 889
对⼀个内部表示成long型的string执行append, setbit, getrange这些命令，针对的仍然是string的值（即⼗进制表示的字符串），而不是针对内部表⽰的long型进⾏操作。因此，在这些命令的实现中，会把long型先转成字符串再进行相应的操作。String 的内部存储结构⼀般是 sds（Simple Dynamic String，可以动态扩展内存），但是如果⼀个String 类型的 value 的值是数字，那么 Redis 内部会把它转成 long 类型来存储，从⽽减少内存的使用。
力扣104题：二叉树最大深度
m0_56332819的博客
07-10 196
二叉树最大深度，C语言
单链表面试题---移除链表元素和翻转链表
2302_80826557的博客
07-11 425
分别定义两个指针，分别为cur和prev，让cur=head.next，让prev=head。如下图cur指针是用来确定该节点的数据是否为要删除的数据，如果cur指向的节点的数据为要删除的数据，则我们让prev.next=cur.next，然后再让cur=cur.next。如果cur指向的节点中的数据不是要删除的，则让prev=cur，cur=cur.next。过程图假设11是我们要删除的数据，则观察图，看到cur指向的数据为11，则执行。
sklearn基础教程：掌握机器学习入门的钥匙
最新发布
AIGC绘图领域探索者，热衷于将创意与技术融合，致力于分享前沿AI绘图技巧与心得，让我们一起开启视觉艺术的新篇章。
07-13 732
是基于Python的一个开源机器学习库，它建立在NumPy、SciPy和matplotlib之上，提供了大量的算法和工具，用于数据挖掘和数据分析。无论是简单的线性回归，还是复杂的神经网络，sklearn都能提供直观易用的接口。作为Python中最为流行的机器学习库之一，以其简洁的API、丰富的算法和强大的功能赢得了广大用户的青睐。通过本文的介绍，相信你已经对sklearn有了初步的了解，并能够开始进行一些基础的机器学习任务。
7.深度学习概述
MechMaster
07-10 956
1. 线性回归 1.1 线性回归一般表达式 1.2 线性回归内积表达方式： 1.3 多个样本时，线性回归的进一步表达： 1.4 线性回归方程的解析 1.5 线性回归就是求loss函数的最小值 2. 如何求函数最小值 2.1 一个例子 2.2 求导法——求最小值 2.3 求导法存在的问题 2.4 迭代法——求最小值 3. 代码实现 3.1 手动求函数最小值 3.2 使用pytorch求函数最小值
代码随想录算法训练营第33天
m0_62262158的博客
07-10 165
【代码】代码随想录算法训练营第33天。
算法模板1
08-08
4. **FFT (快速傅立叶变换) - kuangbin模板**: 快速傅立叶变换是离散傅立叶变换的一种高效算法，这里的模板可能涉及将两个数相乘的高效计算，或者在机器人打高尔夫问题中应用。 5. **KMP算法**: KMP算法是一种字符...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值