vector 邻接表的建立(好笨啊,才懂,可能太困了吧)。。

图的建立有两种,邻接矩阵和邻接表。

邻接矩阵适用于图较为密集,(稀疏图太浪费存储空间了),图如果较为稀疏,则使用邻接表为宜,dijkstra算法就是以邻接表为基础的。

有向无权图

#include<iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
using namespace std;
#define N 100000+5
vector<int >p[N];

int main()
{
    int n,m;
    cin>>n>>m;
    int start,to;
    for (int i=0;i<m;i++)
    {
        cin>>start>>to;
        p[start].push_back(to);
    }
    for (int i=1;i<=n;i++)
    {
        for (int j=0;j<p[i].size();j++)
        {
            cout<<p[i][j]<<" ";
        }cout<<endl;
    }cout<<endl;
}

无向无权图的建立:

#include<iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#include <set>
#include <cstdio>
#include <iterator>
#include <cstring>
using namespace std;
#define N 100000+5
vector<int >p[N];

int main()
{
    int n,m;
    cin>>n>>m;
    int start,to;
    for (int i=0;i<m;i++)
    {
        cin>>start>>to;
        p[start].push_back(to);
        p[to].push_back(start);
    }
    for (int i=1;i<=n;i++)
    {
        for (int j=0;j<p[i].size();j++)
        {
            cout<<p[i][j]<<" ";
        }cout<<endl;
    }cout<<endl;
}

有向有权图的建立:

#include<iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#include <set>
#include <cstdio>
#include <iterator>
#include <sstream>
#include <cmath>
#include <list>
#include <deque>
#include <cstring>
using namespace std;
#define N 100000+5
struct node
{
    int to,cost;
};
vector<node >p[N];

int main()
{
    int n,m;
    cin>>n>>m;
    int start,to;
    for (int i=0;i<m;i++)
    {
        node c;
        cin>>start>>c.to>>c.cost;
        p[start].push_back(c);
    }
    cout<<endl;
    for (int i=1;i<=n;i++)
    {
        for (int j=0;j<p[i].size();j++)
        {
            cout<<i<<" "<<p[i][j].to<<" "<<p[i][j].cost<<" "<<endl;
        }
    }cout<<endl;
}

无向有权图的建立:

时间: 2024-10-06 08:08:37

vector 邻接表的建立(好笨啊,才懂,可能太困了吧)。。的相关文章

ACM:最短路,dijkstra,邻接表的建立,使用邻接表跟优先队列的dijkstra,Bellman-Ford,Floyd。。

(一)dijkstra,邻接矩阵 所有边权均为正,不管有没有环,求单个源点出发,到所有节点的最短路.该方法同时适用于有向图和无向图. #include <iostream> #include <string> #include <stack> using namespace std; const int MAXN = 1000; const int INF = 100000000; int n, m; int maze[MAXN][MAXN], vis[MAXN], d

STL_稀疏图,树_使用vector邻接表存储

本文出自:http://blog.csdn.net/svitter 分析:vector是STL模板中的容器.可以利用其性质来构建邻接表. 定义: #include <vector> #define MAXN 10000 //max n of a tree or graph //if is a tree, n / 2 is OK ; using namespace std; typedef vector<int> vint; vector <vint> G(MAXN);

基于vector的邻接表的建立

/*有向无权图*/ 1 #include <bits/stdc++.h> 2 using namespace std; 3 typedef struct { 4 vector<char> graph; 5 char a; 6 7 }zx[1000]; 8 int main() 9 { 10 zx z; 11 int n,m; 12 cout<<"输入点的数量和边的数量"<<endl; 13 scanf("%d%d",&

HUST 1103 校赛 邻接表-拓扑排序

Description N students were invited to attend a party, every student has some friends, only if someone’s all friends attend this party, this one can attend the party(ofcourse if he/she has no friends, he/she also can attend it.), now i give the frien

Hihocoder 之 #1097 : 最小生成树一&#183;Prim算法 (用vector二维 模拟邻接表,进行prim()生成树算法, *【模板】)

#1097 : 最小生成树一·Prim算法 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 最近,小Hi很喜欢玩的一款游戏模拟城市开放出了新Mod,在这个Mod中,玩家可以拥有不止一个城市了! 但是,问题也接踵而来——小Hi现在手上拥有N座城市,且已知这N座城市中任意两座城市之间建造道路所需要的费用,小Hi希望知道,最少花费多少就可以使得任意两座城市都可以通过所建造的道路互相到达(假设有A.B.C三座城市,只需要在AB之间和BC之间建造道路,那么AC之间也是可以通过

基于邻接表的图建立(有向图+无向图)

图的表示(建立)有两种方法: ①邻接矩阵:A(i,j)=1表示i,j存在一条边,空间复杂度O(n^2),稠密图 ②邻接表:只记录存在的边,Vector+List的数据结构,稀疏图 邻接矩阵的图建立这里不做赘述,接下来我们看一下邻接表的图建立: <1>有向图 注意理解头插入节点的过程 int n,m;//n表示城镇个数,m表示道路条数</span> struct LinkNode//列表节点 { int vex; //邻接的结点在数组中的编号 LinkNode* next; }; s

通用邻接表---vector实现

手写邻接表很麻烦....所以写了一个邻接表模板,方便用 vector实现,使用时看看代码注释即可 #include <iostream> #include <vector> #include <cstdio> #include <malloc.h> #define INF 99999999; #define max_point 1000000 ////定义总共的节点数目 using namespace std; struct node { int u, v,

用邻接表或vector实现存边以及具体如何调用[模板]

存边: 对于指针实现的邻接表: struct edge{ int from,next,to,w; }E[maxn]; int head[maxn],tot=0;//head初始化为-1: void add(int x,int y,int z){ E[++tot].from=x;//头结点 E[tot].to=y;//连接的下一个结点 E[tot].w=z;//边权值 E[tot].next=head[x];//连接指针 head[x]=tot;//指针指向tot,即可通过head[x]为下标,运

邻接表的使用及和vector的比较

这几天碰到一些对建边要求挺高的题目.而vector不好建边,所以学习了邻接表.. 下面是我对邻接表的一些看法. 邻接表的储存方式 邻接表就是就是每个节点的一个链表,并且是头插法建的链表,这里我们首先用数组进行模拟..first [u],next[e]分别表示节点u的第一条边的编号,第e条边的下一条边的编号..则实现代码为: next[e]=head[u[e]]: head[u[e]]=e; 然后如果和结构体进行搭配使用会非常使用.. struct Edge { int to,val,next;