kuangbin 最短路集合

最新推荐文章于 2022-05-29 14:06:43 发布
最新推荐文章于 2022-05-29 14:06:43 发布
阅读量101 收藏
点赞数
分类专栏： 算法 文章标签： 字符串 twitter sdl 分布式计算 dell
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014560290/article/details/111190048
版权

Til the Cows Come Home poj-2387

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<queue>
#include<set>
#include<map>
#include<vector>
using namespace std;
#define INF 0x3f3f3f3f
#define eps 1e-10
#define PI acos(-1.0)
#define _e exp(1.0)
#define ll long long
const int maxn=1e3+5;

int cost[maxn][maxn];
int d[maxn];
bool used[maxn];
int n;

void dijkstra(int s)
{
    fill(d,d+n,INF);
    fill(used,used+n,false);
    d[s]=0;
    while(true)
    {
        int v=-1;
        for(int u=1;u<=n;u++)
        {
            if(!used[u] && (v==-1 || d[u]<d[v]))
                v=u;
        }
        if(v==-1)
            break;
        used[v]=true;
        for(int u=1;u<=n;u++)
            d[u]=min(d[u],d[v]+cost[v][u]);
    }
}
int main()
{
    int T;
    scanf("%d%d",&T,&n);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            cost[i][j]=INF;
    for(int i=0;i<T;i++)
    {
        int u,v,len;
        scanf("%d%d%d",&u,&v,&len);
        {
            if(len<cost[u][v])
            {
              cost[u][v]=len;
              cost[v][u]=len;
            }
        }
    }
    dijkstra(n);
    cout<<d[1]<<endl;
}
View Code

Frogger poj-2253

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<queue>
#include<set>
#include<vector>
using namespace std;
#define INF 0x3f3f3f3f
#define eps 1e-10
#define PI acos(-1.0)
#define _e exp(1.0)
#define ll long long
const int maxn=205;
int x[maxn],y[maxn],n;
double map[maxn][maxn];


void floyd()
{
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                map[i][j]=min(map[i][j],max(map[i][k],map[k][j]));
}
int main()
{
    int ca=1;
    while(~scanf("%d",&n) && n)
    {
        memset(map,0,sizeof(map));
        for(int i=1;i<=n;i++)
        {
            scanf("%d %d",&x[i],&y[i]);
        }
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                map[i][j]=map[j][i]=sqrt(double(x[i]-x[j])*(x[i]-x[j])+double(y[i]-y[j])*(y[i]-y[j]));
        floyd();
        printf("Scenario #%d\nFrog Distance = %.3lf\n\n",ca++,map[1][2]);
        
    }
    return 0;
}
View Code

Heavy Transportation poj-1797

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cstdlib>
#include<queue>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn=1005;

int map[maxn][maxn];
int n,m;

int dijkstra()
{
    int vis[maxn],d[maxn];
    int v;
    for(int i=1;i<=n;i++)
    {
        vis[i]=0;
        d[i]=map[1][i];  //d[]是最大承载量
    }
    for(int i=1;i<=n;i++)
    {
        int f=-1;
        for(int j=1;j<=n;j++)
            if(!vis[j] && d[j]>f)
            {
                f=d[j];
                v=j;
            }
        vis[v]=1;
        for(int j=1;j<=n;j++)
        {
            if(!vis[j] && d[j]<min(d[v],map[v][j]))
                d[j]=min(d[v],map[v][j]);
        }
    }
    return d[n];
}
int main()
{
    int t;
    scanf("%d",&t);
    int ca=1;
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0;i<=n;i++)
            for(int j=0;j<=n;j++)
                map[i][j]=0;
        for(int i=0;i<m;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            map[a][b]=map[b][a]=c;
        }
        printf("Scenario #%d:\n",ca++);
        printf("%d\n\n",dijkstra());
    }
}
View Code

Silver Cow Party poj-3268

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cstdlib>
#include<queue>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn = 1e3 + 5;

int cost[maxn][maxn];
bool used[maxn];
int d[maxn];
int ans[maxn];
int n, m, x;

void dijkstra(int s)
{
    memset(d, INF, sizeof d);
    memset(used, false, sizeof used);
    d[s] = 0;
    while (true)
    {
        int v = -1;
        for (int u = 1; u <= n; u++)
            if (!used[u] && (v == -1 || d[u] < d[v]))
                v = u;
        if (v == -1)
            break;
        used[v] = true;
        for (int u = 1; u <= n; u++)
            d[u] = min(d[u], d[v] + cost[v][u]);
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> m >> x;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            cost[i][j] = INF;
    for (int i = 0; i < m; i++)
    {
        int a, b, l;
        cin >> a >> b >> l;
        cost[a][b] = l;
    }
    dijkstra(x);
    for (int i = 1; i <= n; i++)
    {
        ans[i] = d[i];
    //    cout << d[i] << endl;
    }
        
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            if (i >= j)
                swap(cost[i][j], cost[j][i]);
    dijkstra(x);
    int maxx = 0;
    for (int i = 1; i <= n; i++)
        maxx = max(ans[i] + d[i],maxx);
    cout << maxx << endl;
}
View Code

Currency Exchange poj-1860

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;
#define ll long long

const int maxn=1e2+5;

int n,m,s;
double v;
double g1[maxn][maxn]={0},g2[maxn][maxn]={0};  //g1：a->b汇率  g2：a->b佣金
double map[maxn]={0};  //在某一兑换点的金钱的数额

int floyd()
{
    double d[maxn];
    for(int i=1;i<=n;i++)
        d[i]=map[i];
    for(int k=1;k<=n;k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if ((map[i] - g2[i][j]) * g1[i][j] > map[j]) {
                    map[j] = (map[i] - g2[i][j]) * g1[i][j];
                }
            }
        }
    }
    for(int i=1;i<=n;i++)
        if(d[i]<map[i]) {
            return 1;
        }
        return 0;
}
int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin>>n>>m>>s>>v;   //n:货币的总数，m：兑换点的数目，s：手上钱的类型 v：手上钱的数目
    for(int i=1;i<=m;i++)
    {
        int a,b;
        double c,d,e,f;
        cin>>a>>b>>c>>d>>e>>f;
        g1[a][b]=c;
        g2[a][b]=d;
        g1[b][a]=e;
        g2[b][a]=f;
    }
    map[s]=v;
    floyd();
    if(floyd())
        cout<<"YES"<<endl;
    else
        cout<<"NO"<<endl;
}
View Code

Wormholes poj-3259

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cstdlib>
#include<queue>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn = 1e5 + 5;

int map[505][505],n,m,k,num=0;

void Init()
{
    memset(map,INF,sizeof map);
}

int floyd()
{
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                int t = map[i][k]+map[k][j];
                if(map[i][j] > t)
                    map[i][j]=t;
            }
            if(map[i][i]<0)
                return 1;
        }
    return 0;
}
int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    
    int t;
    cin>>t;
    while(t--)
    {
        Init();
        cin>>n>>m>>k;
        for(int i=1;i<=n;i++)
            map[i][i]=0;
        for(int i=1;i<=m;i++)
        {
            int a,b,c;
            cin>>a>>b>>c;
            if(c<map[a][b])
                map[a][b]=map[b][a]=c;
        }
        for(int i=1;i<=k;i++)
        {
            int a,b,c;
            cin>>a>>b>>c;
            map[a][b]=-c;
        }
        if(floyd())
            puts("YES");
        else
            puts("NO");
    }
    
    
}
View Code

MPI Maelstrom poj-1502

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cstdlib>
#include<queue>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn = 1e5 + 5;
int dis[505];
bool vis[505];
int map[505][505],n,m,k,num=0;
void Init()
{
    memset(map,INF,sizeof map);
    for(int i=1;i<=n;i++)
        map[i][i]=0;
}
void Dijkstra(int start)
{
    for(int i=1;i<=n;i++)
    {
        dis[i]=INF;vis[i]=false;
    }
    dis[start]=0;
    for(int j=1;j<=n;j++)
    {
        int k=-1;
        int Min=INF;
        for(int i=1;i<=n;i++)
            if(!vis[i] && dis[i]<Min)
            {
                Min=dis[i];
                k=i;
            }
        if(k==-1)
            break;
        vis[k]=true;
        for(int i=1;i<=n;i++)
            if(!vis[i] && dis[k]+map[k][i]<dis[i])
            {
                dis[i]=dis[k]+map[k][i];
            }
    }
}
int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
   
    cin>>n;
    Init();
    for(int i=2;i<=n;i++)
        for(int j=1;j<i;j++)
        {
            char str[10];
            cin>>str;
            if(str[0]!='x')
                map[i][j]=map[j][i]=atoi(str);
        }
    Dijkstra(1);
    int sum=0;
    for(int i=2;i<=n;i++)
        sum=max(sum,dis[i]);
    cout<<sum<<endl;

    
}
View Code

Extended Traffic Lightoj-1074

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
    
using namespace std;

const int MaxN=300;
const int MaxM=MaxN*MaxN;
const int INF=10e8;

struct Edge
{
    int to,next,cost;
};

Edge E[MaxM];
int head[MaxN],Ecou;
bool vis[MaxN];
int couNode[MaxN];
bool cir[MaxN];

void init(int N)
{
    Ecou=0;

    for(int i=1;i<=N;++i)
        head[i]=-1,vis[i]=0,cir[i]=0;
}

void addEdge(int u,int v,int c)
{
    E[Ecou].to=v;
    E[Ecou].cost=c;
    E[Ecou].next=head[u];
    head[u]=Ecou++;
}

void dfs(int u)
{
    cir[u]=1;

    for(int i=head[u];i!=-1;i=E[i].next)
        if(!cir[E[i].to])
            dfs(E[i].to);
}

bool SPFA(int lowcost[],int N,int start)
{
    queue <int> que;
    int u,v,c;

    for(int i=1;i<=N;++i)
        lowcost[i]=INF,couNode[i]=0;
    lowcost[start]=0;

    que.push(start);
    vis[start]=1;
    couNode[start]=1;

    while(!que.empty())
    {
        u=que.front();
        que.pop();

        vis[u]=0;            // !!!

        for(int i=head[u];i!=-1;i=E[i].next)
        {
            v=E[i].to;
            c=E[i].cost;

            if(cir[v])
                continue;

            if(lowcost[v]>lowcost[u]+c)
            {
                lowcost[v]=lowcost[u]+c;

                if(!vis[v])
                {
                    vis[v]=1;
                    que.push(v);

                    ++couNode[v];

                    if(couNode[v]>N)
                        dfs(v);
                }
            }
        }
    }

    return 1;
}

int ans[MaxN];
int val[MaxN];

inline int cube(int x)
{
    return x*x*x;
}

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);

    int T;
    int N,Q,M;
    int a,b;
    int cas=1;

    scanf("%d",&T);

    while(T--)
    {
        scanf("%d",&N);
        init(N);

        for(int i=1;i<=N;++i)
            scanf("%d",&val[i]);

        scanf("%d",&M);
        while(M--)
        {
            scanf("%d %d",&a,&b);
            addEdge(a,b,cube(val[b]-val[a]));
        }

        SPFA(ans,N,1);

        scanf("%d",&Q);

        printf("Case %d:\n",cas++);

        while(Q--)
        {
            scanf("%d",&a);

            if(cir[a] || ans[a]<3 || ans[a]==INF)
                printf("?\n");
            else
                printf("%d\n",ans[a]);
        }
    }
    
    return 0;
}
View Code

Cow Contest poj-3660

分析：floyd闭包，看每一头牛是否确定了赢的和输的加起来是n-1，是的话名次就确定了。(vj上g++rt了，c++就ac了)

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include<map>
#include<cmath>

using namespace std;
#define ll long long

const int maxn=1e6+5;
const int INF = 0x3f3f3f3f;

int n,m;
int vis[105][105];

void Init()
{
    memset(vis,0,sizeof vis);
}

void floyd()
{
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            {
                if(vis[i][k]==1 && vis[k][j]==1)
                    vis[i][j]=1;
            }
}
int main()
{
    ios::sync_with_stdio(false);
    while(~scanf("%d%d",&n,&m))
    {
        Init();
        for(int i=1;i<=m;i++)
        {
            int a,b;
            cin>>a>>b;
            vis[a][b]=1;
        }
        floyd();
        int ans=0;
        for(int i=1;i<=n;i++)
        {
            int du=0;
            for(int j=1;j<=n;j++)
            {
                if(vis[i][j]==1 || vis[j][i]==1)
                    du++;
            }
            if(du==n-1)
                ans++;

        }
        cout<<ans<<endl;
    }
}
View Code

Arbitrage poj-2240

分析：map存储字符串对应的编号

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cstdlib>
#include<map>
#include<queue>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn = 1e5 + 5;
int n;
double mp[60][60];
map<string,int>p;
void floyd()
{
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if(mp[i][j]<mp[i][k]*mp[k][j])
                    mp[i][j]=mp[i][k]*mp[k][j];
    return;
}
int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    int ca=1;
    while(~scanf("%d%*c",&n) && n)
    {
        p.clear();
        for(int i=1;i<=n;i++)
        {
            char str[100];
            scanf("%s",str);
            p[str]=i;
            mp[i][i]=1;
        }
        int m;
        scanf("%d%*c",&m);
        for(int i=1;i<=m;i++)
        {
            double a;
            char str1[100],str2[100];
            scanf("%s%lf%s",str1,&a,str2);
            mp[p[str1]][p[str2]]=a;
        }
        floyd();
        bool flag=false;
        for(int i=1;i<=n;i++)
        {
            if(mp[i][i]>1)
            {
                flag=true;
                break;
            }
        }
        if(flag)
            printf("Case %d: Yes\n",ca++);
        else
            printf("Case %d: No\n",ca++);
        
    }
}
View Code

Invitation Cards poj-1511

分析：邻接表存储路径，正反向spfa，用vector寸可能会超时

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include<map>
#include <queue>
#include<vector>
#include<cmath>

using namespace std;
#define ll long long
const int INF = 0x3f3f3f3f;
const int MAXN = 1e6+5;

struct  edge
{
    int to,w,nxt;
};
edge e[MAXN];
int n,cnt,head[MAXN],a1[MAXN],a2[MAXN],c[MAXN];
ll dis[MAXN];

void addedge(int u,int v,int w)
{
    e[cnt].to=v;
    e[cnt].w=w;
    e[cnt].nxt=head[u];
    head[u]=cnt++;
}

ll spfa()
{
    fill(dis,dis+MAXN,INF);
    queue<int>que;
    que.push(1);
    dis[1]=0;
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        for(int i=head[u];i!=-1;i=e[i].nxt){
            if(dis[e[i].to]>dis[u]+e[i].w){
                dis[e[i].to]=dis[u]+e[i].w;
                que.push(e[i].to);
            }
        }
    }
    ll res=0;
    for(int i=1;i<=n;i++)
        res+=dis[i];
    return res;

}
int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int m;
        scanf("%d%d",&n,&m);
        cnt=0;
        fill(head,head+MAXN,-1);
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a1[i],&a2[i],&c[i]);
            addedge(a1[i],a2[i],c[i]);
        }
        ll ans=spfa();
        cnt=0;
        fill(head,head+MAXN,-1);
        for(int i=0;i<m;i++){
            addedge(a2[i],a1[i],c[i]);
        }
        ans+=spfa();
        printf("%lld\n",ans);
    }

}
View Code

Candies poj-3159

分析：还是用邻接表存的路径，spfa用queue会超时，用vector也会超时，用栈的思想可以过，Dijkstra+优先队列也超时。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include<map>
#include <queue>
#include<vector>
#include<cmath>

using namespace std;
#define ll long long
const int INF = 0x3f3f3f3f;
const int MAXN = 1e6+5;

struct  edge
{
    int to,w,nxt;
};
edge e[MAXN];
int n,cnt,head[MAXN];
bool vis[MAXN];
ll dis[MAXN];

void addedge(int u,int v,int w)
{
    e[cnt].to=v;
    e[cnt].w=w;
    e[cnt].nxt=head[u];
    head[u]=cnt++;
}

ll spfa()
{
    fill(dis,dis+MAXN,INF);
    int sta[MAXN];
    memset(vis,false,sizeof vis);
    queue<int>que;
    que.push(1);
    dis[1]=0;
    int top=0;
    sta[++top]=1;
    vis[1]=true;
    while(top)
    {
        int u=sta[top--];
        vis[u]=false;
        for(int i=head[u];i!=-1;i=e[i].nxt)
        {
            int v = e[i].to;
            int w = e[i].w;
            if(dis[v] > dis[u] + w)
            {
                dis[v] = dis[u] + w;
                if(!vis[v])
                {
                    vis[v]=true;
                    sta[++top]= v;
                }
            }
        }
    }
}
int main()
{

        int m;
        scanf("%d%d",&n,&m);
        cnt=0;
        fill(head,head+MAXN,-1);
        for(int i=0;i<m;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            addedge(a,b,c);
        }

        spfa();

        printf("%lld\n",dis[n]);

}
View Code

Subway poj-2502

分析：关键在于寸图

#include <stdio.h>
#include <math.h>
#define maxn 203
#define INF 1e8
#define min(a,b) (a<b?a:b)
#define distance(t,s) sqrt((t.x-s.x)*(t.x-s.x)+(t.y-s.y)*(t.y-s.y))

typedef struct{
    int x,y;
}Point;

Point point[maxn],a;
int n;
double map[maxn][maxn];

int ex(Point t){
    int i;
    for(i=1;i<n;i++){
        if(t.x==point[i].x && t.y==point[i].y) break;
    }
    if(i==n) point[n++]=t;
    return i;
}

void dijkstra(){
    int i,j,v,vis[maxn];
    double min,d[maxn];
    for(i=1;i<n;i++){
        vis[i]=0;
        d[i]=map[1][i];
    }
    for(i=1;i<n;i++){
        min=INF;
        for(j=1;j<n;j++)
            if(!vis[j] && d[j]<min){
                min=d[j];
                v=j;
            }
        vis[v]=1;
        for(j=1;j<n;j++)
            if(!vis[j] && d[j]>map[v][j]+d[v])
                d[j]=map[v][j]+d[v];
    }
    printf("%d\n",(int)(d[2]+0.5));
}


void floyd(){
    int i,j,k;
    for(k=1;k<n;k++)
        for(i=1;i<n;i++)
            for(j=1;j<n;j++)
                if(map[i][j]>map[i][k]+map[k][j])
                    map[i][j]=map[i][k]+map[k][j];
}


int main(){
    int subway[maxn],scnt;
    int i,j,t;
    for(i=1;i<maxn;i++)
        for(j=1;j<maxn;j++)
            if(i==j) map[i][j]=0;
            else map[i][j]=INF;
    n=1;
    scanf("%d%d%d%d",&point[n].x,&point[n].y,&point[n+1].x,&point[n+1].y);
    n+=2;
    while(~scanf("%d%d",&a.x,&a.y)){
        t=n;
        scnt=0;
        subway[scnt++]=ex(a);    //要判断输入的点是否已经存在
        while(scanf("%d%d",&a.x,&a.y) && (a.x!=-1 && a.y!=-1)){
            subway[scnt++]=ex(a);
        }
        for(i=1;i<scnt;i++)        //地铁的站的时间只能是相邻的站点能到，不能从站点1直接到站点n
            map[subway[i]][subway[i-1]]=map[subway[i-1]][subway[i]]=distance(point[subway[i]],point[subway[i-1]])*3.0/2000.0;
    }
    for(i=1;i<n;i++)
        for(j=1;j<=i;j++)
            map[i][j]=map[j][i]=min(map[i][j],distance(point[i],point[j])*3.0/500.0);
    dijkstra();//flpyd()
    return 0;
}
View Code

昂贵的聘礼 poj-1062

分析：在于存图和建立一个新的源点

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<cstdlib>
#include <vector>
#include<queue>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn =  3e5+5;
const ll mod = 1e9+7;
int n,m;
int map[105][105];
int dis[105];
int money[105];
int level[105];
int minLevel;
int vis[105];

void init()
{
    for(int i=0;i<=n;i++)
        for(int j=0;j<=n;j++)
            map[i][j]=(i==j?0:INF);
}

void Dijkstra()
{
    for(int i=0;i<n;i++)
    {
        int minn=INF;
        int u=-1;
        for(int j=1;j<=n;j++) {
            if (level[j] < minLevel || level[j] - minLevel > m)
                continue;
            if (dis[j] < minn && !vis[j]) {
                minn = dis[j];
                u = j;
            }
        }
            if(u==-1)
                break;
            vis[u]=1;
            for(int j=1;j<=n;j++)
            {
                if(level[j] < minLevel || (level[j]-minLevel > m))
                    continue;
                if(!vis[j] && dis[j]>dis[u]+map[u][j])
                    dis[j] = dis[u]+map[u][j];
            }

        
    }
}
int main()
{

    cin>>m>>n;
    init();
    for(int i=1;i<=n;i++)
    {
        int a;
        cin>>money[i]>>level[i]>>a;
        for(int j=0;j<a;j++)
        {
            int b,c;
            cin>>b>>c;
            map[b][i]=c;
        }
        map[0][i]=money[i];
    }
    int ans=INF;
    for(int i=1;i<=n;i++)
    {
        minLevel=level[i];
        for(int j=1;j<=n;j++)
            dis[j]=map[0][j];
        dis[0]=0;
        memset(vis,0,sizeof vis);
        vis[0]=1;
        Dijkstra();
        if(ans>dis[1])
            ans=dis[1];
    }
    cout<<ans<<endl;
}








/*
1 4
10000 3 2
2 8000
3 5000
1000 2 1
4 200
3000 2 1
4 200
50 2 0
 */
View Code

Tram poj-1847

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include<queue>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn =  1e5;
const ll mod = 1e9+7;

struct  node
{
    int u,v,len,next;
}e[maxn];
int dis[maxn],head[maxn];
bool vis[maxn];

void addedge(int u,int v,int len,int k)
{
    e[k].u = u;
    e[k].v = v;
    e[k].len = len;
    e[k].next = head[u];
    head[u] = k;
}

void spfa(int s)
{
    stack<int> sta;
    sta.push(s);
    while(sta.size())
    {
        int i=sta.top();
        sta.pop();
        vis[i] = false;
        for(int j=head[i];j!=0;j=e[j].next)
        {
            int u=e[j].u,v=e[j].v,len=e[j].len;
            if(dis[u]+len < dis[v])
            {
                dis[v] = dis[u]+len;
                if(vis[v] == false)
                {
                    vis[v]=true;
                    sta.push(v);
                }
            }
        }
    }
}
int main()
{
    int N,A,B,k = 1;
    cin>>N>>A>>B;
    memset(head,0,sizeof head);
    for(int i=1;i<=N;i++)
    {
        int M,v;
        dis[i] = INF;
        cin>>M>>v;
        addedge(i,v,0,k++);
        for(int j=1;j<M;j++)
        {
            cin>>v;
            addedge(i,v,1,k++);
        }
    }
    dis[A] = 0;
    spfa(A);
    if(dis[B] == INF)
        cout<<-1<<endl;
    else
        cout<<dis[B]<<endl;


}


/*
3 2 1
2 2 3
2 3 1
2 1 2
 */
View Code
千摆渡w
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kuangbin 模板
09-08
kuangbin 模板
kuangbin的ACM模板（2018.7更新）
07-25
kuangbin说他之前的老模板有一些错误，然后这个月分享给了我们新的模板。本来这个东西是公开的免费的，但是上传资源积分至少1个，不支持免费分享。大家如果没有积分的话可以给我私信，我不忙的时候一定会发的~~~欢迎...
Kuangbin最短路专题
qq_62338494的博客
04-21 498
菜鸡第一篇博客 整理一下kuangbin的最短路专题（主要是ide出问题了没事干 目录 一、POJ 2387 Till the Cows HomeSPFA板子 二、POJ 2253 FroggerDij最大边最短路 三.POJ 1797 Heavy TranspotationDij最小边最长路 四、POJ 3268 Sliver Cow Party反向建图 五、POJ 1860 Currency ExchangeSPFA判正环 六、POJ 3259 Wormhole...
kuangbin最短路专题
HigcMadoka的博客
05-29 209
青蛙POJ2253 传送门 在二维平面上有 n个石头。 第一个石头上有一个青蛙，第二个石头上也有一个青蛙。 第一个石头上的青蛙要到第二个石头上找另一个青蛙玩耍。 它可以直接跳到第二个石头上，也可以经过一系列中间石头，然后再跳到第二个石头上。 这只青蛙希望，它的跳跃过程中，单次跳跃的最长距离尽可能短。 请你计算并输出这个最长距离的最小可能值。 输入格式 输入包含多组测试数据。 每组数据第一行包含一个整数 n。 接下来 n行，第 i 行包含两个整数 xi,yi，表示第 i个石头的位置坐标。 每组数据输入完毕后，
Kuangbin专题四 最短路
hi_One_Month的博客
04-04 577
花了一些时间看了一下最短路，理论ac了这个专题，有些题目自己也写了一下。写几道有代表性的把。 C（这题题解不想自己写了就贴的网上的http://blog.csdn.net/HowardEmily/article/details/53449396?locationNum=1&fps=1） 题意：要从城市1到城市N运送货物，有M条道路，每条道路都有它的最大载重量，问从城市1到城市N运送最多的重
kuangbin专题-最短路练习
small_whl的博客
04-05 354
kuangbin专题题目一 本文是kuangbin专题的最短路练习题解，题解可能写的不是很清晰，不过不重要，代码还是很容易理解的。 做题顺序 Dijkstra 1 7 4 10 3 2 16 sofa 14 12 13 5 15 18 floyd 8 6 9 附上题目链接 kuangbin专题链接 1 Til the Cows Come Home #include<iostream> #include<map> #include<queue> #include<cs
kuangbin最短路 模板
han_hhh的博客
10-10 303
kuangbin最短路 模板 //floyd //复杂度O(N^2) #include&lt;iostream&gt; #include&lt;cstdio&gt; using namespace std; const int INF=0x3f3f3f3f; const int MAXN=1e3+50; int mapp[MAXN][MAXN]; int N,M; int main()...
kuangbin的ACM模板（新）.pdf
11-15
Contents 1 字符串处理 5 1.1 KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.2 e-KMP . . . . . . . . . . . . . . . . . . . . . . . . . . ....
kuangbin的ACM模板（新）_模板_kuangbin_kuangbinacm_ACM_
09-29
kuangbin的ACM模板动态规划计算几何：线与线求交，线与面求交，求凸包，半平面求交等若干图论问题：最小生成树 最短路 强连通分量、桥和割点 等
kuangbin的ACM模板（新）.zip_kuangbin ACM算法模板
09-19
kuangbin巨巨 ACM模板~ 有需要的朋友可以下载了~
kuangbin专题四最短路总结
qq_34921856的博客
01-24 498
之前的专题一和二是搜索，特别是广搜尤其多。而该专题最短路算法又可以写成广搜形式，真的快写吐了。。 基本的d最短路算法都基本掌握了，不管什么形式的都能较快的写出来，不过听学弟说什么spfa的slf和lll优化倒是没见过，希望以后能学习到吧。所以如何建图才是解决问题的关键。 C - Heavy Transportation 找能到终点的所有路径的最小值的最大值。 需要注意，因为要找最大值，那么
kuangbin 最短路专题 - POJ - 3259 Wormholes （最短路 Floyd算法）
ACM-ICPC 现役(铜牌) Codeforces Rating: 2172
10-04 152
kuangbin 最短路专题 - POJ - 3259 Wormholes （最短路 Floyd算法） Floyd原理推荐可以看看这篇：https://blog.csdn.net/m0_46272108/article/details/108919125 #include<cstdio> #include<iostream> #include<cstring> #include<string> #include<cmath> #include&
最短路Flord：kuangbin系列之最短路B
偷吃了老鼠的土豆
06-05 228
题目传送门：Frogger利用了Flord算法：算法讲解参考：福利题目大意，在两个石头之间找到最短路径#include &lt;iostream&gt; #include&lt;stdio.h&gt; #include &lt;vector&gt; #include &lt;algorithm&gt; #include &lt;math.h&gt; #include &lt;iomanip&gt;...
kuangbin专题一 简单搜索
tgyy_cool的博客
04-07 162
Poj 1426 找出一个由1和0组成的十进制数m满足m为n的倍数。 有两种做法，一种是bfs从低位数往高位数搜，另一种是用二叉树数组的结构存每次的求出来的余数，当余数为0时返回下标，然后根据下标求出其对应的数。 1.bfs #include<cstdio> #include<queue> using namespace std; const int INF...
kuangbin区间dp专题
帅气廖鹏飞
10-09 354
文章目录-vj链接：E - Multiplication Puzzle （poj 1651 矩阵连乘） -vj链接： https://vjudge.net/contest/256821#problem/E E - Multiplication Puzzle （poj 1651 矩阵连乘） 以前做过矩阵连乘的问题，这道题推着推着突然发现不就是矩阵连乘的问题么。。。 但是感觉理解得不深入，又重新理解了...
poj 1502 Dijkstra 求最短路径。
ACM梦。。。。
07-29 1641
现在这边感谢喵呜晚上给我讲了Dijkstra 算法思想和编程方法。  昨晚两点睡觉 今天还是那么早就醒，嗯嗯 这样的日子让我觉得很充实。。        这道题是简单题，赤裸裸的Dijkstra算法题。  题意就是求第一个点到各个点最短路径中的最大值。MPI MaelstromT
kuangbin专题一简单搜索：棋盘问题
ffforesttt的博客
07-27 121
原题如下： 在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。 Input 输入含有多组测试数据。 每组数据的第一行是两个正整数，n k，用一个空格隔开，表示了将在一个n*n的矩阵内描述棋盘，以及摆放棋子的数目。 n <= 8 , k <= n 当为-1 -1时表示输入结束。 随后的n行描述了棋盘的形状：每行有n个字符，其中 # 表示棋盘区域，
poj2253_VJkuangbin04最短路练习_Frogger
喵 喵 喵~
06-16 138
题目大意：有n个石头，以下n行是n个石头的坐标，编号1~n。要从1号石头到达2号石头，中间过程只能从一个石头跳到另一个石头上，问在跳的过程中，跳的两块石头的最短距离的最大值(以下简称fdis) floyd算法 dp[i][j]表示从起点i到达终点j的fdis 初始值：i到j的距离 状态转移方程：枚举中间点k，起点i, 终点j if(dp[i][j] &gt; max(dp[i][k]...
kuangbin带你飞——专题六 最小生成树（5）
miaomiaopu的blog
07-10 92
kuangbin带你飞——专题六 最小生成树（3） 专题网址：VJ网址 [kuangbin带你飞]专题1-23 题目来源：ZOJ 1586 QS Network VJ题目 VJ 不能提交，下面给出 ZOJ 该题网站 ZOJ题目 题解 经典最小生成树题型。Kruskal 算法： 题目意思是，如果有两个节点要连接，则需要购买两个适配器和一条网线。适配器只能绑定一条网线，如果该节点仍然需要再连接一条网线，需要再购买适配器。 题目的边权值是两个节点的之和加上边权。 先讲各边从矩阵中提取出，再存边，在按照边权值
并查集板子llkkyyy
最新发布
08-19
并查集是一种常用的数据结构，用于管理一个不相交集合的数据。在并查集中，每个元素都有一个父节点指向它所属的集合的代表元素。通过查找和合并操作，可以判断两个元素是否属于同一个集合，并将它们合并到同一个集合...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值