力扣简单题+最短路径的 prime和kruskal算法

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

class Solution {
     
public:
    vector<int> twoSum(vector<int>& nums, int target) {
     
        map<int,int> a;
        vector<int> b;
        for(int i=0;i<nums.size();i++){
     
            a.insert(map<int,int>::value_type(nums[i],i));
        }
        for(int i=0;i<nums.size();i++){
     
            if(a.count(target-nums[i])&&i!=a[target-nums[i]]){
     
                b.push_back(i);
                b.push_back(a[target-nums[i]]);
                break;
            }
        }
        return b;
    }
};

下面这个值遍历一边，以数组 i 作为一个索引

下面看看prim和kruskal算法

prim算法通过构造一个结构体 如下

 struct Node    //需要用一个结构体来记录产生的最小的生成树 
{
       
    int adjvex;//最小边在U的那个顶点     
    int lowcost;//最小边上的权值    
}MinTree[MaxVexNum]; 

他表示的意思就 adjvex到结构体数组下标的权值是 lowcost
第一次直接填入从K节点找树的边权值，然后遍历剩下的n-1个节点每次更新mintree，然后找出最小的权值输出！在更新时遇到权值比他小的话，就替换adjvex和lowcost

kurskal算法主要是用到了并查集 ，并查集笔记给你 算了 还是留给我自己看吧 ，并查集不会的小伙伴们，大家多去看看 挺不戳的算法 加油加油加油！

#include
using namespace  std;
typedef struct Ding{
     
    int vexnum,edgnum;
    int A[100][100];
    int L[100];
}Ding;
int a[6];
void creategrap(Ding &g){
     
    cout<<"请输入节点数"<<endl;
    cin>>g.vexnum;
    cout<<"请输入边数"<<endl;
    cin>>g.edgnum;
    int x,y,v;
    for (int i = 0; i < g.vexnum;++i) {
     
        g.L[i]=i;
    }
    for (int i = 0; i < g.vexnum; ++i) {
     
        for (int j = 0; j < g.vexnum; ++j) {
     
            if (i==j){
     
                g.A[i][j]=0;
            }else{
     
                g.A[i][j]=50;
            }
        }
    }
    for (int i = 0; i < g.edgnum; ++i) {
     
        cin>>x>>y>>v;
        g.A[x][y]=v;
        g.A[y][x]=v;
    }
    cout<<"邻接矩阵构造完成"<<endl;
}


struct node{
     
    int adjvex;
    int lowcost;
}mintree[500];



void Prim(Ding g,int k){
     //prim 算法
    cout<<"最短路径"<<endl;
    int n=g.vexnum;

    for (int i = 0; i < n; ++i) {
     
        if (i!=k){
     
        mintree[i].adjvex=k;
        mintree[i].lowcost=g.A[i][k];
        }
    }
    mintree[k].lowcost =0;
    int min,uo,vo,sum=0;
    for (int i = 0; i < n-1; ++i) {
     
        min=50;
        for (int j = 0; j < n; ++j) {
     
            if (mintree[j].lowcost>0){
     
                if (mintree[j].lowcost<min){
     
                    min=mintree[j].lowcost;
                    k=j;
                }
            }
        }
        sum=sum+min;
        uo=mintree[k].adjvex;
        vo=mintree[k].lowcost;
        cout<<'['<<uo<<" "<<k<<']'<<endl;
        mintree[k].lowcost=0;
        for (int j = 0; j < n; ++j) {
     
            if (mintree[j].lowcost>g.A[k][j]){
     
                mintree[j].adjvex=g.L[k];
                mintree[j].lowcost=g.A[k][j];
            }
        }
    }
    cout<<"最小长度为"<<sum<<endl;
}



int getroot(int p){
     
    while (a[p]!=p){
     
        p=a[p];
    }
    return p;
}
void join(int x,int y){
     
    int tx=getroot(x);
    int ty=getroot(y);
    if(tx!=ty){
     
        a[tx]=ty;
    }
}
void Kruskal(Ding g){
     
    for (int i= 0; i <g.vexnum ; ++i) {
     
        a[i]=i;
    }
    int sum=0;
    for (int i = 0; i < g.vexnum - 1; ++i) {
     
        int min=50;
        int x,y;
        for (int j = 0; j < g.vexnum; ++j) {
     
            for (int k = 0; k < g.vexnum; ++k) {
     
                if(g.A[j][k]<min&&g.A[j][k]>0&&getroot(j)!=getroot(k)){
     
                    x=j;
                    y=k;
                    min=g.A[j][k];
                }
            }
        }
        join(x,y);
        cout<<"["<<x<<" "<<y<<']'<<endl;
        sum+=min;
        g.A[x][y]=0;
        g.A[y][x]=0;
    }
    cout<<"最短路径长度是"<<sum<<endl;
}
int main(){
     
    Ding g;
    creategrap(g);
    Prim(g,0);
    Kruskal(g);
}