图

1.学习总结 1.1图的思维导图 1.2 图结构学习体会 深度遍历算法：使用递归方式，一个结点再往下一个结点的遍历，不遍历已访问过的结点 广度遍历算法：用队列的方式，将一个结点的周边结点扫入队列中，再按出队的顺序依次访问，重复操作。

 

3

#include <iostream>
#include <fstream>
#include <cstdio>
#include <queue>
#include <vector>
using namespace std;
const int maxn=10005;
 
int vertices, edges;
vector<int> G[maxn];  //每个vector结构的元素表示：与数组下标代表的结点有边的结点
bool vis[maxn];     //是否访问过
         
int BFS(int v)
{
    for(int i=0; i<maxn; i++)
        vis[i]=false;
    int tail;   //用于记录每层压入时的结点
    int last=v;     //记录每层的最后一个元素：该层压入之后弹出之前更新：last=temp；
    int count=1;
    int level=0;
 
    vis[v]=true;
    queue<int> q;
    q.push(v);
     
    while(!q.empty())
    {
        int x=q.front();    //弹出x
        q.pop();
        for(int j=0; j<G[x].size(); j++) //x的一圈压入队列
        {
            if(!vis[G[x][j]])   //若未被访问过：访问并压入队列
            {
                vis[G[x][j]]=true;              
                q.push(G[x][j]);
                tail=G[x][j];   //记录压入的结点
                count++;
            }   
        }
        if(x==last) //一层全部弹出，准备开始弹下一层：弹出的(x)=当前层最后一个元素(last)
        {
            last=tail;    //一层全都压入完后，更新last
            level++;
        }
        if(level==6)
            break;  
    }
    return count;
}
int main(int argc, char** argv) {   
    int x,y;
    cin >> vertices >> edges;
    //ifstream fin("test.txt");
    //fin >> vertices >> edges;
     
    for(int i=1; i<=edges; i++)
    {
        cin >> x >> y;
        //fin >> x >> y;
        G[x].push_back(y);
        G[y].push_back(x);
    }
    for(int j=1; j<=vertices; j++)
    {
        //cout << BFS(j) << endl;
        printf("%d: %.2lf%%\n", j, BFS(j)*1.0/vertices*100.0);  
    }
    return 0;
}

 

 

 

 

 4

#include<iostream>  
    #include<algorithm>  
    using namespace std;  
    const int inf=10000000;  
    const int N=1002;  
    int G[N][N];  
    int d[N];  
    int n,m;  
    bool vis[N]={false};  
    int prim()  
    {  
        fill(d,d+N,inf);  
        d[1]=0;  
        int ans=0;  
        for(int i=1;i<=n;i++)  
        {  
            int u=-1;  
            int min=inf;  
            for(int j=1;j<=n;j++)  
            {  
                if(vis[j]==false&&d[j]<min)  
                {  
                    u=j;  
                    min=d[j];  
                }  
            }  
            if(u==-1)  
            return -1;  
            vis[u]=true;  
            ans+=d[u];  
            for(int v=1;v<=n;v++)  
            {  
                if(vis[v]==false&&G[u][v]!=inf&&G[u][v]<d[v])  
                d[v]=G[u][v];  
             }   
        }   
        return ans;  
     }   
     int main()  
     {  
        int u,v,c;  
        cin>>n>>m;  
        fill(G[0],G[0]+N*N,inf);  
        for(int i=1;i<=m;i++)  
        {  
            cin>>u>>v>>c;  
            G[u][v]=G[v][u]=c;  
        }  
        int ans=prim();  
        if(ans==-1)  
        cout<<"Impossible";  
        else  
        cout<<ans;  
        return 0;  
     } 

 

 

 

 

 

5

#include<cstdio>  
#include<cstring>  
#include<cstdlib>  
#include<cstring>  
#include<cmath>  
#include<stack>  
#include<queue>  
#include<algorithm>  
using namespace std;  
struct node  
{  
    int u,v,w;  
    bool operator < (const node &x)const  
    {  
        return w<x.w;  
    }  
} q[1000002];  
int e=0;  
int fa[100002];  
int findset(int x)  
{  
    return fa[x]!=x?fa[x]=findset(fa[x]):x;  
}  
int main()  
{  
    int n,m;  
    scanf("%d%d",&n,&m);  
    int i,j;  
    for(i=0;i<m;i++)  
        scanf("%d%d%d",&q[i].u,&q[i].v,&q[i].w);  
    sort(q,q+m);  
    for(i=0;i<=n;i++)  
        fa[i]=i;  
    int ans=0;  
    int cnt=0;  
    int f=0;  
    for(int k=0;k<m;k++)  
    {  
        if(findset(q[k].u)!=findset(q[k].v))  
        {  
            fa[fa[q[k].u]]=fa[q[k].v];  
            ans+=q[k].w;  
            cnt++;  
            if(cnt==n-1)  
        {  
                f=1;  
        break;  
        }  
        }  
    }  
    if(f)  
    printf("%d",ans);  
    else  
        printf("Impossible");  
    return 0;  
}