URAL 1934 spfa算法

D - Black Spot

Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u

Submit Status Practice URAL 1934

Description

Bootstrap: Jones's terrible leviathan will find you and drag the Pearl back to the depths and you along with it.
Jack: Any idea when Jones might release said terrible beastie?

Bootstrap: I already told you, Jack. Your time is up. It
comes now, drawn with ravenous hunger to the man what bears the black
spot.

Captain Jack Sparrow has got a black spot on his hand and he avoids
going to high seas because sea monster Kraken is waiting there for him.
But he can’t stay in his place due to his freedom-loving nature. And now
Jack is going to Tortuga.

There are n
islands in the Caribbean Sea. Jack is going to reach Tortuga, sailing
from island to island by routes that allow him to be in the high seas
for a short time. Jack knows such routes for some pairs of islands, but
they could also be dangerous for him. There is a probability to meet
Kraken on each route.

Jack is in a hurry and he wants to reach Tortuga visiting as small
number of islands as possible. If there are several variants of such
paths he wants to choose a path with the least probability of meeting
Kraken.
But Jack will be satisfied with any path with minimal number of
islands if the probability of meeting Kraken on this path differs from
the minimal one in no more than 10⁻⁶. Help Jack find such path.

Input

The first line contains two integers n,
m — the quantity of islands and known routes between them (2 ≤
n ≤ 10 ⁵; 1 ≤
m ≤ 10 ⁵). The second line contains two integers s and t — the number of island where Jack is and the number of Tortuga (1 ≤
s,
t ≤
n;
s ≠
t). Each of the following m lines contains three integers — the numbers of islands a_i and b_i where the route is known and p_i — probability to meet Kraken on that route as percentage (1 ≤
a_i,
b_i ≤
n;
a_i ≠
b_i; 0 ≤
p_i ≤ 99). No more than one route is known between each pair of islands.

Output

In the first line output k — number of islands along the path and p — probability to meet Kraken on that path. An absolute error of p should be up to 10 ⁻⁶. In the next line output k integers — numbers of islands in the order of the path. If there are several solutions, output any of them.

Sample Input

input	output
4 4 1 3 1 2 50 2 3 50 1 4 10 4 3 10	3 0.19 1 4 3

#include<stdio.h>
#include<iostream>
#include<queue>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn=;
int n,m;
bool vis[maxn];
int  before[maxn],dis[maxn];
const int inf=;
int first[maxn];
int cnt;

double tp[maxn];

struct node
{
    int v;
    double p;
    int next;
} que[maxn<<];

void addedge(int a,int b,double c)
{
    que[cnt].v=b;
    que[cnt].p=c;
    que[cnt].next=first[a];
    first[a]=cnt;
    cnt++;
}
void spfa(int u)
{
    memset(tp,,sizeof(tp));
    tp[u]=;
    memset(vis,false,sizeof(vis));
    vis[u]=true;
    memset(before,-,sizeof(before));
  for(int i=;i<=n;i++)
  dis[i]=inf;
    dis[u]=;

    queue<int>q;
    q.push(u);
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        vis[x]=false;

        for(int i=first[x]; i!=-; i=que[i].next)
        {
            int v=que[i].v;
            if(dis[v]>dis[x]+)
            {
                dis[v]=dis[x]+;
                before[v]=x;
                tp[v]=tp[x]*que[i].p;
                if(!vis[v])
                {
                    vis[v]=true;
                    q.push(v);
                }
            }
            else  if(dis[v]==dis[x]+)
            {
                if(tp[x]*que[i].p>tp[v])
                {
                    tp[v]=tp[x]*que[i].p;
                    before[v]=x;

                    if(!vis[v])
                    {
                        vis[v]=true;
                        q.push(v);
                    }
                }
            }
        }

    }
    return ;
}
int ans[maxn];
void outp(int tend){
    memset(ans,,sizeof(ans));
    int cnt=-;
    for(int i=tend;i!=-;i=before[i]){
        ans[++cnt]=i;
    }

    for(int i=cnt;i>=;i--){
        printf("%d%c",ans[i],i==?'\n':' ');
    }
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {

        memset(first,-,sizeof(first));
      int start,tend;
        scanf("%d%d",&start,&tend);
        cnt=;
        for(int i=; i<=m; i++)
        {
            int t1,t2;
            double t3;
            scanf("%d%d%lf",&t1,&t2,&t3);
            addedge(t1,t2,-t3/);
            addedge(t2,t1,-t3/);
        }

        spfa(start);
        printf("%d %.8lf\n",dis[tend]+,-tp[tend]);
         outp(tend);

    }
    return ;
}