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 ...

随机推荐

51nod 1554：欧姆诺姆和项链——题解
http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1554 题目: 有一天,欧姆诺姆发现了一串长度为n的宝石串,上面有五颜六色 ...
poj2409:Let it Bead(置换群 polya定理)
题目大意:长度为n的项链,要染m种颜色,可以通过旋转或翻转到达的状态视为同一种,问有多少种染色方案. 学了一波polya定理,发现很好理解啊,其实就是burnside定理的扩展. burnside定理 ...
《python核心编程》--读书笔记第21章数据库编程
准备:今天拿笔记本装了mysql,这样就能在不同地方用其他电脑远程访问同一个数据库了. python安装MySQLdb模块:http://www.codegood.com/downloads. 21. ...
tomcat7 access log设置
位置:${tomcat_home}/conf/server.xml <Valve className="org.apache.catalina.valves.AccessLogValv ...
[技巧篇]01.Servlet的优化模版代码
Servlet.java的模版 #---------------------------------------------# # <aw:description>Template for ...
mysql 可视化界面操作指令
1.让自增长从新开始 ALTER TABLE users auto_increment =1;//让表中的自增长从新从0开始 2.条件查询 SELECT name from users WHERE ...
Android Studio键盘快捷键
Android Studio 为许多常用操作提供了键盘快捷键. 表 1 按操作系统显示了默认键盘快捷键. 注:除了下面表 1 中的默认键映射外,您还可以选择多种预设的键映射,也可以创建自定义键映射.如 ...
密码本（无bug版）
main.cpp #include <stdio.h> #include <stdlib.h> #include "data.h" #include &qu ...
HDU 1159 Common Subsequence （dp）
题目链接 Problem Description A subsequence of a given sequence is the given sequence with some elements ...
hadoop+spark 集群的安装
1.安装连接 https://www.cnblogs.com/zengxiaoliang/p/6478859.html

POJ-3268

POJ-3268的更多相关文章

随机推荐

热门专题