【星门跳跃】解题报告

My Flag:通过

题目类型 最短路

提交该题

讨论该问题

有关讨论

相关题解

最优解

题目难度得分:2分

题目质量得分:3分

目前共有:7人进行评分

题目评分
查看题目 Show Problem

[Donate]您的捐助，让RQNOJ明天更美好!

题目:星门跳跃

问题编号:341
题目描述

在EVE游戏中，宇宙被划分成为许多区域，每个区域中都有数目不定的星门，可以通过星门来跳跃到特定的区域（星门是双向的）。
现在你正参与BBE联军与MLGBD联盟的会战，但由于飞船受损，需要尽快回到后方的友军空间站进行维护。
试编写程序，计算出所须的最短的返回空间站时间。
为了简化问题，我们约定飞船所在的位置为区域1，空间站所在的位置为区域N。

问题规模：
对于80%的数据，1<N<=10000，1<M<50000；
对于100%的数据，1<N<=30000，1<M<150000，1<=X[],Y[]<=N，1<=Z[]<=4096；
输入格式

第1行，两个整数N,M，分别为区域的总数和星门的总数；
第2..M+1行，每行三个整数X[i],Y[i],Z[i]，分别为星门连接的两个区域，以及跳跃所需时间；
输出格式

一个整数，返回空间站所需的最短时间。

星门跳跃，简单题。见注释

/*                                            *\
    提交了n次，对拍了几分钟
    第一次 裸spfa wa80
    第二次 尝试使用SLF优化，仍然不过
    第三次 尝试使用前向星，wa80
    第N次 wa80
    
    最后发现题目范围看错了，因此边表开小了
    看到了80%的数据m<=50000，所以开的100000
    但是其实100%的数据m<=150000
    
    
    最后测试的时候发现SLF优化也可以
    只是因为用的cin、cout所以超时。
    scanf和printf就好了
    
    SLF优化(341.cpp)要点：
    
         1、比较新节点和队首节点时队首为que[l+1]
         2、插入队首时要后递减que[l--] = ths->index;
         3、SLF的原理见http://tieba.baidu.com/f?kz=1192850879
         （貌似网上都说用SLF再加LLL，反而会更慢）
    
    
    前向星是个好东西啊，以后存储都常用前向星了
    前向星要点：
         1、读入边表
         2、根据起始点排序
         3、计算以每个点为起始点的数组中一段的边
                 for (long i=1;i<m+1;i++)
                    if (f[bian[i].f]==0)
                        f[bian[i].f]=i;
        (优化：链式前向星
        http://www.cnblogs.com/ACoder/archive/2011/04/06/2006323.html)
        
    空间优化 循环队列
        要点：
            1、判断队列为空：只能用if (f!=r)
                            if (f<r)是错误的
             2、取余操作：只要加到f、r操作的
                             所有地方就行了
        
        
        
    另外 Heap+dijkstra也很高效，代码实现复杂一些
    
\*                                            */

#include <cstdio>
#include <cstdlib>
long n;long m;

struct ftv
{
    long f;
    long t;
    long v;
};
ftv bian[300004];

long top = 0;
long que[10000000];
bool used[30002];
long dist[30002];
long f[30002];

void insert(long a,long b,long c)
{
    top ++;
    bian[top].f = a;
    bian[top].t = b;
    bian[top].v = c;
}

void input()
{
    scanf("%ld %ld",&n,&m);
    for (long i=1;i<m+1;i++)
    {
        long a;long b;long c;
        scanf("%ld %ld %ld",&a,&b,&c);
        insert(a,b,c);
        insert(b,a,c);
    }
}

void spfa()
{
    for (long i=1;i<n+1;i++)
    {
        dist[i] = 19940701;
    }
    dist[1] = 0;
    long l=0;long r=0;
    r++;
    que[r] = 1;

    while (l<r)
    {
        l++;
        long now = que[l];
        used[now] = false;
        long i = f[now];
        if (i!=0)
        {
            while (bian[i].f==now)
            {
                if (dist[bian[i].t]>dist[now]+bian[i].v)
                {
                    dist[bian[i].t]=dist[now]+bian[i].v;
                    if(!used[bian[i].t])
                    {
                        used[bian[i].t] = true;
                        r++;
                        que[r] = bian[i].t;
                    }
                }
                i++;
            }
        }
    }
}

int bigger(const void* a,const void* b)
{
    ftv* aa = (ftv*)a;
    ftv* bb = (ftv*)b;
    long aaa = aa->f;
    long bbb = bb->f;
    if (aaa>bbb)
    {
        return 1;
    }
    else if (aaa==bbb)
    {
        return 0;
    }
    else return -1;
}

int main()
{
//    freopen("door.in","r",stdin);
//    freopen("door.out","w",stdout);
    input();
    m<<=1;
    qsort(bian+1,m,sizeof(ftv),&bigger);
    for (long i=1;i<m+1;i++)
        if (f[bian[i].f]==0)
            f[bian[i].f]=i;
    spfa();
    
    printf("%ld",dist[n]);
}

SLF优化版本AC

#include <cstdio>
//using std::cout;
//using std::cin;

long n;long m;

struct tnode
{
	long index;
	tnode* next;
	long pow;
};

tnode* door[30002];
long que[3000000];
bool used[30002];
long dist[30002];

void insert(long a,long b,long c)
{
	tnode* nnode = new tnode;
	nnode->index = b;
	nnode->next = door[a];
	nnode->pow = c;
	door[a] = nnode;
}

void input()
{
	scanf("%ld %ld",&n,&m);
	for (long i=1;i<m+1;i++)
	{
		long a;long b;long c;
		scanf("%ld %ld %ld",&a,&b,&c);
		insert(a,b,c);
		insert(b,a,c);
	}
}

void spfa()
{
	for (long i=1;i<n+1;i++)
	{
		dist[i] = 0x7fff0000;
	}
	dist[n] = 0;
	long l=0;long r=0;
	r++;
	que[r] = n;

	while (l<r)
	{
		l++;
		long now = que[l];
		tnode* ths = door[now];
		used[now] = false;
		while (ths)
		{
			if (dist[ths->index]>dist[now]+ths->pow)
			{
				dist[ths->index] = dist[now]+ths->pow;
				if (!used[ths->index])
				{
					/*								*\
						分两种情况如果队列为空
						或者队首较小都插到队首
						
						队列为空时虽然队首队尾含义相同
						但是采取++r防止下标越界 
					\*								*/ 
					
					if (dist[ths->index]>=dist[que[l+1]]||l==0)
					{
						used[ths->index] = true;
						que[++r] = ths->index;
					}
					else
					{
						used[ths->index] = true;
						que[l--] = ths->index;
					}
				}
			}
			ths = ths->next;
		}
		
	}
}

int main()
{
	input();
	spfa();
	printf("%ld",dist[1]);
}