MPI Maelstrom
Time Limit: 1000MS   Memory Limit: 10000K
Total Submissions: 5538   Accepted: 3451

Description

BIT has recently taken delivery of their new supercomputer, a 32 processor Apollo Odyssey distributed shared memory machine with a hierarchical communication subsystem. Valentine McKee's research advisor, Jack Swigert, has asked her to benchmark the new system. 

``Since the Apollo is a distributed shared memory machine, memory access and communication times are not uniform,'' Valentine told Swigert. ``Communication is fast between processors that share the same memory subsystem, but it is slower between processors
that are not on the same subsystem. Communication between the Apollo and machines in our lab is slower yet.'' 



``How is Apollo's port of the Message Passing Interface (MPI) working out?'' Swigert asked. 



``Not so well,'' Valentine replied. ``To do a broadcast of a message from one processor to all the other n-1 processors, they just do a sequence of n-1 sends. That really serializes things and kills the performance.'' 



``Is there anything you can do to fix that?'' 



``Yes,'' smiled Valentine. ``There is. Once the first processor has sent the message to another, those two can then send messages to two other hosts at the same time. Then there will be four hosts that can send, and so on.'' 



``Ah, so you can do the broadcast as a binary tree!'' 



``Not really a binary tree -- there are some particular features of our network that we should exploit. The interface cards we have allow each processor to simultaneously send messages to any number of the other processors connected to it. However, the messages
don't necessarily arrive at the destinations at the same time -- there is a communication cost involved. In general, we need to take into account the communication costs for each link in our network topologies and plan accordingly to minimize the total time
required to do a broadcast.''

Input

The input will describe the topology of a network connecting n processors. The first line of the input will be n, the number of processors, such that 1 <= n <= 100. 



The rest of the input defines an adjacency matrix, A. The adjacency matrix is square and of size n x n. Each of its entries will be either an integer or the character x. The value of A(i,j) indicates the expense of sending a message directly from node i to
node j. A value of x for A(i,j) indicates that a message cannot be sent directly from node i to node j. 



Note that for a node to send a message to itself does not require network communication, so A(i,i) = 0 for 1 <= i <= n. Also, you may assume that the network is undirected (messages can go in either direction with equal overhead), so that A(i,j) = A(j,i). Thus
only the entries on the (strictly) lower triangular portion of A will be supplied. 



The input to your program will be the lower triangular section of A. That is, the second line of input will contain one entry, A(2,1). The next line will contain two entries, A(3,1) and A(3,2), and so on.

Output

Your program should output the minimum communication time required to broadcast a message from the first processor to all the other processors.

Sample Input

5
50
30 5
100 20 50
10 x x 10

Sample Output

35




解题思路:
	题意就是n台机器相互发送信息,要求从第一台机器,把剩下的n-1台都发送完所需的最小时间数。
	裸Dijkstra,用邻接矩阵存储。

首先注意矩阵的初始化操作,主对角线赋值0,由于自己给自己发消息没意义。其它点设为无穷大。

接下来比較奇葩的就是它的输入。它是依照下三角矩阵输入的,g[i][j] = g[j][i],对称的两个点权值同样。

假设输入为x,那么代表i到j没有边,保持无穷大。
	以下上模板,最后在求出的dis数组里遍历,寻找最大值。那个就是我们所求的最短所需时间。

(这里有点别扭。能够这么理解,dis[i]代表src源点到i的最短时间。既然n个点都要遍历。那么时间数一定要大于等于dis里的最大值才干够)
	最后,输入处理那看到有人直接用函数做的······我函数知道的少就直接模拟转换了····感觉自己萌萌哒····

完整代码:
#include <functional>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <numeric>
#include <cstring>
#include <climits>
#include <cassert>
#include <complex>
#include <cstdio>
#include <string>
#include <vector>
#include <bitset>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <list>
#include <set>
#include <map>
using namespace std; #pragma comment(linker, "/STACK:102400000,102400000") typedef long long LL;
typedef double DB;
typedef unsigned uint;
typedef unsigned long long uLL; /** Constant List .. **/ //{ const int MOD = int(1e9)+7;
const int INF = 0x3f3f3f3f;
const LL INFF = 0x3f3f3f3f3f3f3f3fLL;
const DB EPS = 1e-9;
const DB OO = 1e20;
const DB PI = acos(-1.0); //M_PI;
int n;
string s;
int g[201][201];
int dis[201];
bool vis[201];
int res; void init()
{
for(int i = 1 ; i <= n ; i ++)
{
for(int j = 1; j <= n ; j ++)
{
if(i == j)
g[i][j] = 0;
else
g[i][j] = INF;
}
}
} void dijkstra()
{
for(int i = 1 ; i <= n ; i ++)
{
dis[i] = INF;
}
dis[1] = 0;
memset(vis , 0 , sizeof(vis));
for(int i = 1; i <= n ; i ++)
{
int mark = -1;
int mindis = INF;
for(int j = 1 ; j <= n ; j ++)
{
if(!vis[j] && dis[j] < mindis)
{
mindis = dis[j];
mark = j;
}
}
vis[mark] = 1;
for(int j = 1 ; j <= n ; j ++)
{
if(!vis[j])
{
dis[j] = min(dis[j] , dis[mark] + g[mark][j]);
}
} }
res = -INF;
for(int k = 1 ; k <= n ; k ++)
{
if(dis[k] > res)
res = dis[k];
}
} int main()
{
#ifdef DoubleQ
freopen("in.txt","r",stdin);
#endif
while(~scanf("%d",&n))
{
init();
for(int i = 2 ; i <= n ; i ++)
{
for(int j = 1 ; j < i ; j ++)
{
cin >> s;
if(s == "x")
continue;
else
{
int sum = 0;
int jin = 1;
int len = s.length();
for(int k = len - 1 ; k >= 0 ; k --)
{
if(k != len - 1)
jin *= 10;
sum += jin * (s[k] - '0');
}
g[i][j] = sum;
g[j][i] = sum;
}
}
}
dijkstra();
cout << res << endl;
}
}

POJ1502(Dijkstra)的更多相关文章

  1. 迪杰斯特拉(dijkstra)算法的简要理解和c语言实现(源码)

    迪杰斯特拉(dijkstra)算法:求最短路径的算法,数据结构课程中学习的内容. 1 . 理解 算法思想::设G=(V,E)是一个带权有向图,把图中顶点集合V分成两组,第一组为已求出最短路径的顶点集合 ...

  2. 最短路径之迪杰斯特拉(Dijkstra)算法

    迪杰斯特拉(Dijkstra)算法主要是针对没有负值的有向图,求解其中的单一起点到其他顶点的最短路径算法.本文主要总结迪杰斯特拉(Dijkstra)算法的原理和算法流程,最后通过程序实现在一个带权值的 ...

  3. 理解最短路径——迪杰斯特拉(dijkstra)算法

    原址地址:http://ibupu.link/?id=29 1.       迪杰斯特拉算法简介 迪杰斯特拉(dijkstra)算法是典型的用来解决最短路径的算法,也是很多教程中的范例,由荷兰计算机科 ...

  4. 图论——迪杰斯特拉算法(Dijkstra)实现,leetcode

    迪杰斯特拉算法(Dijkstra):求一点到另外一点的最短距离 两种实现方法: 邻接矩阵,时间复杂度O(n^2) 邻接表+优先队列,时间复杂度O(mlogn)(适用于稀疏图) (n:图的节点数,m:图 ...

  5. 算法-迪杰斯特拉算法(dijkstra)-最短路径

    迪杰斯特拉算法(dijkstra)-最短路径 简介: 迪杰斯特拉算法是由荷兰计算机科学家狄克斯特拉于1959 年提出的,因此又叫狄克斯特拉算法.是从一个顶点到其余各顶点的最短路径算法,解决的是有向图中 ...

  6. 数据结构与算法——迪杰斯特拉(Dijkstra)算法

    tip:这个算法真的很难讲解,有些地方只能意会了,多思考多看几遍还是可以弄懂的. 应用场景-最短路径问题 战争时期,胜利乡有 7 个村庄 (A, B, C, D, E, F, G) ,现在有六个邮差, ...

  7. poj1062昂贵的聘礼(Dijkstra**)

    /* 题意: 物主有一个物品,价值为P,地位为L, 以及一系列的替代品Ti和该替代品所对应的"优惠"Vi g[u][i] 表示的是u物品被i物品替换后的优惠价格!(u>0, ...

  8. C++之路进阶——优先队列优化最短路径算法(dijkstra)

    一般的dijkstra算法利用贪心的思想,每次找出最短边,然后优化到其他点的的距离,我们还采用贪心思路,但在寻找最短边进行优化,之前是双重for循环,现在我们用优先队列来实现. 代码解释: //样例程 ...

  9. nyoj 1238 最少换乘(dijkstra)

    描述 欧洲某城是一个著名的旅游胜地,每年都有成千上万的人前来观光旅行.Dr. Kong决定利用暑假好好游览一番.. 年轻人旅游不怕辛苦,不怕劳累,只要费用低就行.但Dr. Kong年过半百,他希望乘坐 ...

随机推荐

  1. byte为什么要与上0xff(转)

    无意间翻看之间的代码,发现了一段难以理解的代码. byte[] bs = digest.digest(origin.getBytes(Charset.forName(charsetName))) ; ...

  2. 打开excel2007文档时显示“excel无法打开文件~$book.xltm”

    此问题的出现是因为意外情况导致Excel临时文件没有删掉,把C:\Program Files\Microsoft Office\Office12\XLSTART里面的临时文件“~$book”给删除就好 ...

  3. 用Stack实现对多线程的管理范例

    多线程就是并发技术,当线程数量超过一定数量时,系统响应就会变慢,所以就必须对线程数量进行控制,那么采用哪种控制方法呢?采用Stack类模仿堆栈,之所以说是模仿,就是因为Stack类毕竟不是真实的堆栈, ...

  4. 忽然想到:把Mu的源代码一网打尽

    那么那些流媒体开发的公司,就不会拒绝我了,真是一举两得.

  5. 与众不同 windows phone (19) - Device(设备)之陀螺仪传感器, Motion API

    原文:与众不同 windows phone (19) - Device(设备)之陀螺仪传感器, Motion API [索引页][源码下载] 与众不同 windows phone (19) - Dev ...

  6. 通过加载Kernel32来动态判断 当前操作系统32bit还是64bit

    工作原理:通过加载Kernel32来获取IsWow64Process 函数然后通过函数的地址操作,执行函数的操作. 在程序中只要我们获取了一个函数的地址,就可以找到正确的方法执行这个函数. 但是这种方 ...

  7. HttpGet协议与正则表达

    使用HttpGet协议与正则表达实现桌面版的糗事百科   写在前面 最近在重温asp.net,找了一本相关的书籍.本书在第一章就讲了,在不使用浏览器的情况下生成一个web请求,获取服务器返回的内容.于 ...

  8. 浅谈 Python 程序和 C 程序的整合

    源地址:http://www.ibm.com/developerworks/cn/linux/l-cn-pythonandc/ 概览 Python 是一种用于快速开发软件的编程语言,它的语法比较简单, ...

  9. 从零開始学习制作H5应用——V5.0:懊悔机制,整理文件夹,压缩,模板化

    经过前面四个版本号的迭代.我们已经制作了一个从视觉和听觉上都非常舒服的H5微场景应用,没有看过的请戳以下: V1.0--简单页面滑动切换 V2.0--多页切换.透明过渡及交互指示 V3.0--增加lo ...

  10. zoj3795 Grouping --- 良好的沟通,寻找最长的公路

    给定一个图,为了保持图分裂至少成多个集合的集合内可以使点没有直接或间接的关系. 首先,题意可以得到图中可能含有环.该环的内侧是肯定是要被拆卸. 图点降低建DAG画画,能想象..图从零点渗透深入,在点中 ...