• POJ2253 Frogger


    题意:

    在第一块石头到到第二块石头的通路中,每一条通路的元素都是这条通路中前后两个点的距离,这些距离中有一个最大距离,如果有多条通路,则求出所有通路的最大距离,并把这些最大距离作比较,把最小的一个最大距离输出。    

    dijkstra和spfa 写的  总感觉还是dijkstra比较好理解  。。。。。。  做了poj1797后 才发现 果然还是spfa最好用

    spfa:

    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <queue>
    #include <cmath>
    #define mem(a,b) memset(a,b,sizeof(a))
    using namespace std;
    const int maxn = 101000, INF = 0xfffffff;
    int head[maxn],vis[maxn];
    double d[maxn];
    int n;
    struct tmp{
        double x,y;
    }Tmp[maxn];
    
    struct node{
        int u,v,next;
        double d;
    }Node[maxn];
    
    void add(int u,int v,double d,int i)
    {
        Node[i].u = u;
        Node[i].v = v;
        Node[i].d = d;
        Node[i].next = head[u];
        head[u] = i;
    }
    void spfa(int s)
    {
        mem(vis,0);
        queue<int> Q;
        for(int i=0;i<=n;i++) d[i] = INF;
        d[s] = 0;
        Q.push(s);
        vis[s] = 1;
        while(!Q.empty())
        {
            int x = Q.front();Q.pop();
            vis[x] = 0;
            for(int i=head[x]; i!=-1; i=Node[i].next)
            {
                node e = Node[i];
                if(d[e.v] > max(d[x],e.d))
                {
                    d[e.v] = max(d[x],e.d);
                    if(!vis[e.v])
                    {
                        Q.push(e.v);
                        vis[e.v] = 1;
                    }
                }
            }
        }
    }
    int main()
    {
        int ans = 0;
        while(cin>>n && n)
        {
            int cnt = 0;
            mem(head,-1);
            for(int i=1;i<=n;i++)
            {
                cin>>Tmp[i].x>>Tmp[i].y;
            }
            for(int i=1;i<=n;i++)
            {
                for(int j=i;j<=n;j++)
                {
                    add(i,j,sqrt((Tmp[i].x-Tmp[j].x)*(Tmp[i].x-Tmp[j].x) + (Tmp[i].y-Tmp[j].y)*(Tmp[i].y-Tmp[j].y)),cnt++);
                    add(j,i,sqrt((Tmp[i].x-Tmp[j].x)*(Tmp[i].x-Tmp[j].x) + (Tmp[i].y-Tmp[j].y)*(Tmp[i].y-Tmp[j].y)),cnt++);
                }
    
            }
            spfa(1);
            printf("Scenario #%d\n",++ans);
            printf("Frog Distance = %.3f\n",d[2]);
            cout<<endl;
    
        }
    
    
    
    
        return 0;
    }

    dijkstra:

    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <vector>
    #include <queue>
    #include <cmath>
    #define mem(a,b) memset(a,b,sizeof(a))
    using namespace std;
    const int maxn = 10010, INF = 0xfffffff;
    int n,m;
    int vis[maxn];
    double d[maxn];
    struct node2{
        double x,y;
    }Node[maxn];
    
    
    struct edge{
        int u,v;
        double d;
        edge(int u,int v,double d)
        {
            this->u = u;
            this->v = v;
            this->d = d;
    
        }
    
    };
    vector<edge> Edge;
    vector<int> G[maxn];
    struct node{
        int u;
        double d;
        node(double d,int u)
        {
            this->d = d;
            this->u = u;
    
        }
        bool operator < (const node& a) const {
            return d > a.d;
        }
    };
    void add(int u,int v,double d)
    {
        Edge.push_back(edge(u,v,d));
        G[u].push_back(Edge.size()-1);
    }
    void dijkstra(int s)
    {
        priority_queue<node> Q;
        for(int i=0;i<=n;i++) d[i] = INF;
        d[s] = 0;
        mem(vis,0);
        Q.push(node(0,s));
        while(!Q.empty())
        {
            node x = Q.top();Q.pop();
            int u = x.u;
            if(vis[u]) continue;
            vis[u] = 1;
            for(int i=0;i<G[u].size();i++)
            {
                edge e = Edge[G[u][i]];
                if(d[e.v] > max(d[u], e.d))
                {
                    d[e.v] = max(d[u], e.d);
                    Q.push(node(d[e.v],e.v));
                }
            }
        }
    }
    
    
    
    int main()
    {
        int cnt = 0;
        while(cin>>n && n)
        {
            for(int i=0;i<=n;i++) G[i].clear();
            Edge.clear();
            for(int i=1;i<=n;i++)
            {
                cin>>Node[i].x>>Node[i].y;
            }
            for(int i=1;i<=n;i++)
                for(int j=i;j<=n;j++)
                {
                    add(i,j,sqrt((Node[i].x-Node[j].x)*(Node[i].x-Node[j].x)+(Node[i].y-Node[j].y)*(Node[i].y-Node[j].y)));
                    add(j,i,sqrt((Node[i].x-Node[j].x)*(Node[i].x-Node[j].x)+(Node[i].y-Node[j].y)*(Node[i].y-Node[j].y)));
                }
            dijkstra(1);
            printf("Scenario #%d\n",++cnt);
            printf("Frog Distance = %.3f\n",d[2]);
            cout<<endl;
        }
        return 0;
    }

    Floyd:

    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <cmath>
    #define mem(a,b) memset(a,b,sizeof(b))
    using namespace std;
    const int maxn = 202, INF = 2000;
    struct edge{
        double x,y;
    }Edge[maxn];
    double d[maxn][maxn];
    int main()
    {
        int n,cnt = 0;
        while(cin>>n && n)
        {
    
            for(int i=1;i<=n;i++)
                cin>>Edge[i].x>>Edge[i].y;
            for(int i=1;i<=n;i++)
                for(int j=1;j<=n;j++)
                    d[i][j] = d[j][i] = sqrt(pow(Edge[i].x-Edge[j].x,2)+pow(Edge[i].y-Edge[j].y,2));
            for(int k=1;k<=n;k++)
                for(int i=1;i<=n;i++)
                    for(int j=1;j<=n;j++)
                        d[i][j] = min(d[i][j],max(d[i][k],d[k][j]));
            printf("Scenario #%d\n",++cnt);
            printf("Frog Distance = %.3f\n",d[1][2]);
            cout<<endl;
        }
    
        return 0;
    }
  • 相关阅读:
    wcf 调试
    adf 笔记
    oracle 自定义比较函数
    【SpringMVC】SpringMVC系列3之@PathVariable映射URL占位符参数
    【SpringMVC】SpringMVC系列2之@RequestMapping 映射约束请求
    【SpringMVC】SpringMVC系列1之HelloWorld
    【持续集成】[Jenkins]Job中如何传递自定义变量
    【持续集成】使用Jenkins实现多平台并行集成
    【云计算】Netflix 开源持续交付平台 Spinnaker
    【Other】推荐点好听的钢琴曲
  • 原文地址:https://www.cnblogs.com/WTSRUVF/p/9108344.html
Copyright © 2020-2023  润新知