边表+SPFA (使用指针+动态内存)

233

只是我怕忘了怎么写指针操作 所以写一遍指针版的

然而洛谷评测机不给力,400多ms过了数组的,600多ms过指针的。。。

我想,指针的比数组的理解起来应该容易一点吧

戳我是数组版的,NOIP时候还是用数组为好,万一出现了点bug不就爆零了啊

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
struct edge
{
    int v,w;
    edge*next;
};
edge*link[10001];
int d[10001],n,m,s,X,Y,Z;
bool v[10001];
queue<int>q;
void add(int u,int v,int w)
{
    edge*p=new edge;
    p->v=v;
    p->w=w;
    p->next=link[u];
    link[u]=p;
}
void digui(edge*p)
{
	if(p==NULL)return;

	if(p->next!=NULL)
		digui(p->next);
	delete p;
	p=NULL;
}
void remove()
{
	for(int i=1;i<=n;i++)
		digui(link[i]);
}
int main()
{
    cin >> n >> m >> s;//分别为顶点数 有向边数 源点
    for(int i=1;i<=m;i++)
    {
        cin >> X >> Y >> Z;//是有向边 x->y 长度z
        add(X,Y,Z);
    }
    q.push(s);
    v[s]=true;
    for(int i=1;i<=n;i++)
    	d[i]=2147483647;
    d[s]=0;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        v[x]=false;
        for(edge*i=link[x];i!=0;i=i->next)
        {
            if(d[x]+i->w<d[i->v])
            {
                d[i->v]=d[x]+i->w;
                if(v[i->v]==false)
                {
                    v[i->v]=true;
                    q.push(i->v);
                }
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        cout << d[i] << ‘ ‘;
    }
    remove();
    return 0;
}

233

233

时间: 2024-12-26 19:51:55

边表+SPFA (使用指针+动态内存)的相关文章

指针 &amp;&amp; 动态内存分配

C++中的动态内存分配机制 c++中使用new和delete来完成在堆上对动态内存的分配和释放. 注.所有指针都应该被初始化 如果指针指向的动态内存被释放或没有指向合法的地址,就应该将指针设置为nullptr,否则内存泄漏. 变量: double* pvalue {}; pvalue=new double; *pvalue=9.0; 或 double* pvalue {}; pvalue=new double {9.0}; 或合并为一句 double* pvalue {new double{9.

C++笔记(12):动态内存和智能指针

动态内存和智能指针 动态内存: 1.针对堆里面存放的对象 2.使用new delete运算符 3.智能指针:shared_ptr(多个指针指向同一个对象);  unique_ptr(一个指针指向一个对象);     weak_ptr(弱引用,管理shared_ptr) 4.标准库函数:make_shared<int>()

C++ Primer笔记8_动态内存_智能指针

1.动态内存 C++中,动态内存管理是通过一对运算符完成的:new和delete.C语言中通过malloc与free函数来实现先动态内存的分配与释放.C++中new与delete的实现其实会调用malloc与free. new分配: 分配变量空间: int *a = new int; // 不初始化 int *b = new int(10); //初始化为10 string *str = new string(10, ); 分配数组空间: int *arr = new int[10];//分配的

【C++】动态内存与智能指针

C++常见的内存分配方式有三种: 从静态存储区分配,这里主要是存储局部static对象,类的static成员以及定义在函数之外的变量: 从栈内存分配,这里主要是存储函数内的非static对象: 从堆内存动态分配 其中,静态存储区以及栈内存中的对象,都是由编译器自动创建和销毁,而堆内存中的对象都是由程序显示控制的,通常都是new创建delete销毁或者malloc创建free销毁.动态内存的管理非常棘手,如果动态地创建了对象却没有显式得销毁,就会发生内存泄漏:如果在还有指针引用的时候释放了内存就会

线性表的动态内存分配顺序存储结构

1.线性表是最简单的一种数据结构,很容易实现其中单个元素的存取操作,但是对于插入和删除操作需要大量的移动.比较适用于相对稳定的线性表. 2.数据元素 struct SqList { ElemType * elem ; //存储空间基址 int length ; //当前长度 int listsize ; //当前分配的存储容量 }; 3.创建一个空的线性表 void InitList(SqList &L) { //构造一个空的顺序线性表L L.elem = (ElemType*)malloc(L

【足迹C++primer】39、动态内存与智能指针(3)

动态内存与智能指针(3) /** * 功能:动态内存与智能指针 * 时间:2014年7月8日15:33:58 * 作者:cutter_point */ #include<iostream> #include<vector> #include<memory> #include<string> using namespace std; /** 智能指针和异常 */ void f() { shared_ptr<int> sp(new int(42));

【足迹C++primer】39、动态内存与智能指针(2)

动态内存与智能指针(2) 直接管理内存 void fun1() { //此new表达式在自由空间构造一个int型对象,并返回指向该对象的指针 int *pi1=new int; //pi指向一个动态分配.未初始化的无名对象 string *ps3=new string; //初始化为空string int *pi2=new int; //pi指向一个未初始化的int int *pi3=new int(1024); //pi指向的对象的值为1024 string *ps4=new string(1

动态内存与智能指针

一.shared_ptr 最安全的分配和使用动态内存的方法是调用一个名为make_shared的标准库函数.此函数在动态内存中分配一个对象并初始化它,返回指向此对象的shared_ptr. 1 shared_ptr<int> p3 = make_shared<int>(42); 2 shared_ptr<string> p4 = make_shared<string>(10, '9'); 3 shared_ptr<int> p5 = make_s

动态内存和智能指针

c++中动态内存的管理是通过一对运算符来完成的:new.在动态内存中为对象分配空间并返回一个指向该对象的指针,我们呢,可以选择对对象进行初始化,delete接受一个动态对象的指针,销毁该对象,并返回与之关联的内存. 动态内存的使用的不足: 1.保证在正que的时间释放内存是及其困难 2.有时我们会忘记释放内存,这样就导致内存泄漏 3.有时还存在引用内存的情况,但是我们已经释放了它,这样就导致非法内存的指针 这样就产生了智能指针(smart pointer)来动态管理内存,智能指针优点: 1.行为