POJ-3268

Silver Cow Party

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 13738		Accepted: 6195

Description

One cow from each of N farms (1 ≤ N ≤ 1000) conveniently numbered 1..N is going to attend the big cow party to be held at farm #X (1 ≤ X ≤ N). A total of M (1 ≤ M ≤ 100,000) unidirectional (one-way roads connects pairs of farms; road i requires T_i (1 ≤ T_i ≤ 100) units of time to traverse.

Each cow must walk to the party and, when the party is over, return to her farm. Each cow is lazy and thus picks an optimal route with the shortest time. A cow's return route might be different from her original route to the party since roads are one-way.

Of all the cows, what is the longest amount of time a cow must spend walking to the party and back?

Input

Line 1: Three space-separated integers, respectively: N, M, and X
Lines 2..M+1: Line i+1 describes road i with three space-separated integers: A_i, B_i, and T_i. The described road runs from farm A_i to farm B_i, requiring T_i time units to traverse.

Output

Line 1: One integer: the maximum of time any one cow must walk.

Sample Input

Sample Output

Hint

Cow 4 proceeds directly to the party (3 units) and returns via farms 1 and 3 (7 units), for a total of 10 time units

/**

          题意：最短路中哪个走的路程最大

          解法：SPFA

**/

#include<iostream>

#include<string.h>

#include<stdio.h>

#include<algorithm>

#include<cmath>

#include<queue>

#include<vector>

#define maxn 1000 + 10

#define INF 0x3f3f3f3f

using namespace std;

int vis[maxn];

int dist[maxn];

int dist1[maxn];

int flag[maxn];

struct Node

{

    int v;

    int cost;

    Node(int _v,int _cost):v(_v),cost(_cost) {}

};

vector<Node>edge[maxn];

vector<Node>edge1[maxn];

int n,m,p;

void addedge(int u,int v,int w)

{

    edge[u].push_back(Node(v,w));

    edge1[v].push_back(Node(u,w));

}

void SPFA(int start)

{

    memset(vis,,sizeof(vis));

    memset(dist,INF,sizeof(dist));

    queue<int>que;

    que.push(start);

    vis[start] = ;

    dist[start] = ;

    while(!que.empty())

    {

        int tt = que.front();

        que.pop();

        vis[tt] = ;

        for(int i=; i<edge[tt].size(); i++)

        {

            int mm = edge[tt][i].v;

            if(dist[mm] > dist[tt] + edge[tt][i].cost)

            {

                dist[mm] = dist[tt] + edge[tt][i].cost;

                if(!vis[mm])

                {

                    vis[mm] = ;

                    que.push(mm);

                }

            }

        }

    }

    memset(vis,,sizeof(vis));

    memset(dist1,INF,sizeof(dist1));

    while(!que.empty()) que.pop();

    vis[start] = ;

    dist1[start] = ;

    que.push(start);

    while(!que.empty())

    {

        int tt = que.front();

        que.pop();

        vis[tt] = ;

        for(int i=; i<edge1[tt].size(); i++)

        {

            int mm = edge1[tt][i].v;

            if(dist1[mm] > dist1[tt] + edge1[tt][i].cost)

            {

                dist1[mm] = dist1[tt] + edge1[tt][i].cost;

                if(!vis[mm])

                {

                    vis[mm] = ;

                    que.push(mm);

                }

            }

        }

    }

    return ;

}

int main()

{

//#ifndef ONLINE_JUDGE

//          freopen("in.txt","r",stdin);

//#endif // ONLINE_JUDGE

    scanf("%d %d %d",&n,&m,&p);

    int u,v,w;

    for(int i=; i<m; i++)

    {

        scanf("%d %d %d",&u,&v,&w);

        addedge(u,v,w);

    }

    SPFA(p);

    int mmax = -INF;

    for(int i=; i<=n; i++)

    {

        if(dist[i] + dist1[i] > mmax && dist[i] != INF && dist1[i]!= INF )

            mmax = dist[i] + dist1[i];

    }

    printf("%d\n",mmax);

    return ;

}

/**

          题意：最短路中哪个走的路程最大

          解法：SPFA

**/

#include<iostream>

#include<string.h>

#include<stdio.h>

#include<algorithm>

#include<cmath>

#include<queue>

#include<vector>

#define maxn 1000 + 10

#define INF 0x3f3f3f3f

using namespace std;

int vis[maxn];

int dist[maxn];

int dist1[maxn];

int flag[maxn];

struct Node

{

    int v;

    int cost;

    Node(int _v,int _cost):v(_v),cost(_cost) {}

};

vector<Node>edge[maxn];

vector<Node>edge1[maxn];

int n,m,p;

void addedge(int u,int v,int w)

{

    edge[u].push_back(Node(v,w));

    edge1[v].push_back(Node(u,w));

}

void SPFA(int start)

{

    memset(vis,,sizeof(vis));

    memset(dist,INF,sizeof(dist));

    queue<int>que;

    que.push(start);

    vis[start] = ;

    dist[start] = ;

    while(!que.empty())

    {

        int tt = que.front();

        que.pop();

        vis[tt] = ;

        for(int i=; i<edge[tt].size(); i++)

        {

            int mm = edge[tt][i].v;

            if(dist[mm] > dist[tt] + edge[tt][i].cost)

            {

                dist[mm] = dist[tt] + edge[tt][i].cost;

                if(!vis[mm])

                {

                    vis[mm] = ;

                    que.push(mm);

                }

            }

        }

    }

    memset(vis,,sizeof(vis));

    memset(dist1,INF,sizeof(dist1));

    while(!que.empty()) que.pop();

    vis[start] = ;

    dist1[start] = ;

    que.push(start);

    while(!que.empty())

    {

        int tt = que.front();

        que.pop();

        vis[tt] = ;

        for(int i=; i<edge1[tt].size(); i++)

        {

            int mm = edge1[tt][i].v;

            if(dist1[mm] > dist1[tt] + edge1[tt][i].cost)

            {

                dist1[mm] = dist1[tt] + edge1[tt][i].cost;

                if(!vis[mm])

                {

                    vis[mm] = ;

                    que.push(mm);

                }

            }

        }

    }

    return ;

}

int main()

{

//#ifndef ONLINE_JUDGE

//          freopen("in.txt","r",stdin);

//#endif // ONLINE_JUDGE

    scanf("%d %d %d",&n,&m,&p);

    int u,v,w;

    for(int i=; i<m; i++)

    {

        scanf("%d %d %d",&u,&v,&w);

        addedge(u,v,w);

    }

    SPFA(p);

    int mmax = -INF;

    for(int i=; i<=n; i++)

    {

        if(dist[i] + dist1[i] > mmax && dist[i] != INF && dist1[i]!= INF )

            mmax = dist[i] + dist1[i];

    }

    printf("%d\n",mmax);

    return ;

}

/**

          题意：最短路中哪个走的路程最大

          解法：SPFA

**/

#include<iostream>

#include<string.h>

#include<stdio.h>

#include<algorithm>

#include<cmath>

#include<queue>

#include<vector>

#define maxn 1000 + 10

#define INF 0x3f3f3f3f

using namespace std;

int vis[maxn];

int dist[maxn];

int dist1[maxn];

int flag[maxn];

struct Node

{

    int v;

    int cost;

    Node(int _v,int _cost):v(_v),cost(_cost) {}

};

vector<Node>edge[maxn];

vector<Node>edge1[maxn];

int n,m,p;

void addedge(int u,int v,int w)

{

    edge[u].push_back(Node(v,w));

    edge1[v].push_back(Node(u,w));

}

void SPFA(int start)

{

    memset(vis,,sizeof(vis));

    memset(dist,INF,sizeof(dist));

    queue<int>que;

    que.push(start);

    vis[start] = ;

    dist[start] = ;

    while(!que.empty())

    {

        int tt = que.front();

        que.pop();

        vis[tt] = ;

        for(int i=; i<edge[tt].size(); i++)

        {

            int mm = edge[tt][i].v;

            if(dist[mm] > dist[tt] + edge[tt][i].cost)

            {

                dist[mm] = dist[tt] + edge[tt][i].cost;

                if(!vis[mm])

                {

                    vis[mm] = ;

                    que.push(mm);

                }

            }

        }

    }

    memset(vis,,sizeof(vis));

    memset(dist1,INF,sizeof(dist1));

    while(!que.empty()) que.pop();

    vis[start] = ;

    dist1[start] = ;

    que.push(start);

    while(!que.empty())

    {

        int tt = que.front();

        que.pop();

        vis[tt] = ;

        for(int i=; i<edge1[tt].size(); i++)

        {

            int mm = edge1[tt][i].v;

            if(dist1[mm] > dist1[tt] + edge1[tt][i].cost)

            {

                dist1[mm] = dist1[tt] + edge1[tt][i].cost;

                if(!vis[mm])

                {

                    vis[mm] = ;

                    que.push(mm);

                }

            }

        }

    }

    return ;

}

int main()

{

//#ifndef ONLINE_JUDGE

//          freopen("in.txt","r",stdin);

//#endif // ONLINE_JUDGE

    scanf("%d %d %d",&n,&m,&p);

    int u,v,w;

    for(int i=; i<m; i++)

    {

        scanf("%d %d %d",&u,&v,&w);

        addedge(u,v,w);

    }

    SPFA(p);

    int mmax = -INF;

    for(int i=; i<=n; i++)

    {

        if(dist[i] + dist1[i] > mmax && dist[i] != INF && dist1[i]!= INF )

            mmax = dist[i] + dist1[i];

    }

    printf("%d\n",mmax);

    return ;

}

POJ-3268的更多相关文章

DIjkstra(反向边) POJ 3268 Silver Cow Party || POJ 1511 Invitation Cards
题目传送门 1 2 题意:有向图,所有点先走到x点,在从x点返回,问其中最大的某点最短路程分析:对图正反都跑一次最短路,开两个数组记录x到其余点的距离,这样就能求出来的最短路以及回去的最短路. PO ...
POJ 3268 Silver Cow Party （最短路径）
POJ 3268 Silver Cow Party (最短路径) Description One cow from each of N farms (1 ≤ N ≤ 1000) convenientl ...
POJ 3268——Silver Cow Party——————【最短路、Dijkstra、反向建图】
Silver Cow Party Time Limit:2000MS Memory Limit:65536KB 64bit IO Format:%I64d & %I64u Su ...
POJ 3268 Silver Cow Party 最短路—dijkstra算法的优化。
POJ 3268 Silver Cow Party Description One cow from each of N farms (1 ≤ N ≤ 1000) conveniently numbe ...
poj 3268(spfa)
http://poj.org/problem?id=3268 对于这道题,我想说的就是日了狗了,什么鬼,定义的一个数值的前后顺序不同,一个就TLE,一个就A,还16MS. 感觉人生观都奔溃了,果然,题 ...
POJ 3268 Silver Cow Party （双向dijkstra）
题目链接:http://poj.org/problem?id=3268 Silver Cow Party Time Limit: 2000MS Memory Limit: 65536K Total ...
poj - 3268 Silver Cow Party (求给定两点之间的最短路）
http://poj.org/problem?id=3268 每头牛都要去标号为X的农场参加一个party,农场总共有N个(标号为1-n),总共有M单向路联通,每头牛参加完party之后需要返回自己的 ...
<poj - 3268> Silver Cow Party 牛のpart 最短路径问题
本题链接 : http://poj.org/problem?id=3268 题目大意:牛们要去聚会,输入N = 顶点数(牛场):M = 边(路)的数目: X = 终点 (聚会点).问题:求来回时间的最 ...
POJ 3268 (dijkstra变形)
题目链接 :http://poj.org/problem?id=3268 Description One cow from each of N farms (1 ≤ N ≤ 1000) conveni ...
POJ 3268 Silver Cow Party 最短路
原题链接:http://poj.org/problem?id=3268 Silver Cow Party Time Limit: 2000MS Memory Limit: 65536K Total ...

随机推荐

Leetcode中字符串总结
本文是个人对LeetCode中字符串类型题目的总结,纯属个人感悟,若有不妥的地方,欢迎指出. 一.有关数字 1.数转换题Interger to roman和Roman to integer这两题是罗 ...
项目管理---git----快速使用git笔记(五)------本地项目代码提交到远程仓库---新建项目
上一篇我们已经知道了怎么从远程仓库获取项目文件代码. 项目管理---git----快速使用git笔记(四)------远程项目代码的首次获取 git还有一种使用场景是我本来在电脑里就有一个项目,现在 ...
MFC中用正则表达式进行有效性验证
转载自:http://blog.csdn.net/jinhill/article/details/5928993 正则表达式最实用的一个地方是验证用户输入.它可以轻松验证邮编.电话号码.信用卡号码-- ...
深度解析Java多线程的内存模型
内部java内存模型硬件层面的内存模型 Java内存模型和硬件内存模型的联系共享对象的可见性资源竞速 Java内存模型很好的说明了JVM是如何在内存里工作的,JVM可以理解为java执行的一个操 ...
搜索：N皇后
N皇后问题是DFS的代表性问题,其最难的地方就是在判重这里,想明白了怎么判重的话问题就很显然了. 这里给出两份代码,其中第一份代码的效率更好,就是在判重上下了功夫.当然,我记得还有使用位运算进行判重的 ...
Linux系统基本网络配置之ifconfig命令
Linux系统基本网络配置之ifconfig命令一.Linux系统的网络配置基本包括:网络IP的配置.网关路由的配置.主机DNS的配置.主机名的配置等,本篇注重介绍网络IP的配置. 二.Linux系 ...
vue数组操作不触发前端重新渲染
暂时使用给数组先赋值 [ ] ,然后重新赋值的方式解决. 此外,能够监听的数组变异方法 https://cn.vuejs.org/v2/guide/list.html#%E5%8F%98%E5%BC% ...
1.0 docker介绍
简介: 一种虚拟化的方案将应用程序自动部署到容器特点: 轻量环境的一直性提高开发生命周期使用面向服务的架构场景: 开发.测试.部署创建隔离的运行环境集群测试环境云计算应用 ...
python 实现二叉树相关算法
一.构建与遍历二叉树基本性质 1)在二叉树的第i层上最多有2i-1 个节点 .(i>=1)2)二叉树中如果深度为k,那么最多有2k-1个节点.(k>=1)3)在完全二叉树中,具有n个节点 ...
hadoop入门学习
hadoop入门学习:http://edu.csdn.net/course/detail/1397hadoop hadoop2视频:http://pan.baidu.com/s/1o6uy7Q6HDF ...

POJ-3268

POJ-3268的更多相关文章

随机推荐

热门专题