转载---谷歌 六度空间搜索

http://www.csdn.net/article/2012-09-14/2809957-six-degrees-of-kevin-bacon

Six Degrees of Separation

翻译应该确切是 六度分割理论搜索，中国人的六度空间，有其宗教意义。

伟大的作品，总是从猜想开始。

典型的NP-hard（最短路径问题），解决方法有：

Dijkstra算法
A*算法
SPFA算法
Bellman-Ford算法
Floyd-Warshall算法
Johnson算法

Dijkstra ,Floyd就是重提。

A*如下：A*（A-Star)算法是一种静态路网中求解最短路最有

  

效的方法。

　　公式表示为： f(n)=g(n)+h(n),

　　其中 f(n) 是从初始点经由节点n到目标点的估价函数，

　　g(n) 是在状态空间中从初始节点到n节点的实际代价，

　　h(n) 是从n到目标节点最佳路径的估计代价。

　　保证找到 最短路径 （最优解的）条件，关键在于估价函数h(n)的选取：

　　估价值h(n)<= n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低。但能得到最优解。

　　如果 估价值>实际值, 搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。

SPFA：　定理： 只要最短路径存在，上述SPFA算法必定能求出最小值。

　　证明：每次将点放入队尾，都是经过 松弛操作 达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个 结点 都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。（证毕）

　　期望的时间复杂度O(ke）， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。

　　实现方法：建立一个 队列 ，初始时队列里只有起始点，再建立一个 表格 记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点去刷新起始点到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空

　　判断有无负环：如果某个点进入队列的次数超过N次则存在负环 (存在负环则无最短路径，如果有负环则会无限 松弛 ，而一个带n个点的图至多松弛n-1次）

Johnson算法：

双机流水作业调度问题的Johnson算法

n个作业要在由两台机器M1和M2组成的流水线上完成加工. 每个作业i必须先在M1上然后在M2上加工, 时间分别为ai和bi

确定这n个作业的加工顺序, 使得从第一个任务开始在M1上加工到最后一个任务在M2上加工完成的总时间尽量小

Johnson算法.
设N1为a<b的作业集合, N2为a>=b的作业集合, 将N1的作业按a非减序排序, N2中的作业按照b非增序排序, 则N1作业接N2作业构成最优顺序.(证明略)

2008-12-27 00:53

求解流水作业调度问题的Johnson算法具体描述如下： 
（1） 设a[i]和b[i]（0<=i<n）分别为作业i在两台设备上的处理时间。建立由三元组（作业号，处理时间，设备号）组成的三元组表d。其中，处理时间是指每个作业所包含的两个任务中时间较少的处理时间。
设n=4，（a0,a1,a2,a3）=（3,4,8,10）和（b0,b1,b2,b3）=（6,2,9,15）的作业0的三元组为（0，3，0），作业1的三元组为（1，2，1）……如图（a）所示。 
（2） 对三元组表按处理时间排序，得到排序后的三元组表d。如图（b）所示。 
（3） 对三元组表的每一项d（i）(0<=i<n),从左右两端生成最优作业排列c[j](0<=j<n),c[j]是作业号。如果d[i]设备号为1，则将作业i置于c的左端末尾，否则置于c的右端末尾。如图（c）所示，由两端想中间存放。

作业号 处理时间 设备号 
0 0       3       0 
1 1       2       1 
2 2       8       0 
3 3       10      0 
(a)三元组表

作业号 处理时间 设备号 
0 1       2       1 
1 0       3       0 
2 2       8       0 
3 3       10      0 
(b)按处理时间排序

(0, 2, 3, 1) 
(c)最优作业排列

P1 3 8 10 4 
P2 6 9 15 2 
(d)最优调度方案

程序是流水作业调度的Johnson算法。 
Johnson算法

#include<iostream>
#include<algorithm>
using namespace std;

struct Triplet{        //三元组结构 
    int operator<(const Triplet & b)const {return t <b.t;} 
    int jobNo,t,ab;       //jobNo为作业,体委处理时间,ab为设备号 
};

void FlowShop(int n,int *a,int*b,int*c) 
{ 
Triplet d[n]; 
for(int i=0;i<n;i++) //算法步骤(1),生成三元组表d 
if (a[i]<b[i])
{ 
     d[i].jobNo=i;d[i].ab=0;d[i].t=a[i]; 
} 
else 
{ 
     d[i].jobNo=i;d[i].ab=1;d[i].t=b[i]; 
} 
sort(d,d+n);//算法步骤(2),排序
int left=0,right=n-1; 
for(int i=0;i<n;i++) //算法步骤(3),生成最优解 
    if (d[i].ab==0) c[left++]=d[i].jobNo; 
    else c[right--]=d[i].jobNo; 
}

int main()
{
    int a[4]={3,4,8,10};
    int b[4]={6,2,9,15};
    int c[4];
    FlowShop(4,a,b,c);
    for(int i=0;i<4;++i)
      cout<<c[i]<<" ";
    cout<<endl;
    system("pause");
    return 0;
}

Johnson算法的时间取决于对作业集合的排序,因此,在最怀情况下算法的时间复杂度为O(nlogn),所需的空间复杂度为O(n).

北大PKU POJ 2751 Saving Endeavour问题就是2台机器，n件任务，必须先在S1上做，再在S2上做。任务之间先做后做任意。求最早的完工时间。
这是一个经典问题：2台机器的情况下有多项式算法（Johnson算法），3台或以上的机器是NP-hard的。思想就是贪心，时间复杂度是O(nlogn) 。
Johnson算法
(1)把作业按工序加工时间分成两个子集，第一个集合中在S1上做的时间比在S2上少，其它的作业放到第二个集合。先完成第一个集合里面的作业，再完成第二个集合里的作业。
(2)对于第一个集合，其中的作业顺序是按在S1上的时间的不减排列；对于第二个集合，其中的作业顺序是按在S2上的时间的不增排列。
My Code:
/*
双机调度问题Johnson算法:
(1) 把作业按工序加工时间分成两个子集，第一个集合中在S1上做的时间比在S2上少，
其它的作业放到第二个集合。先完成第一个集合里面的作业，再完成第二个集合
里的作业。
(2) 对于第一个集合，其中的作业顺序是按在S1上的时间的不减排列；对于第二个集
合，其中的作业顺序是按在S2上的时间的不增排列。
*/ 复制内容到剪贴板 代码:#include <stdio.h>
#include <memory.h>
#include <algorithm>
using namespace std;

const int MAXN=10005;

struct TNode
{
int s1,s2;
}ws[MAXN];

int topf,tops;
int n;

bool operator<(TNode x,TNode y)
{
if (x.s1<x.s2&&y.s1>=y.s2) return true;
if (x.s1<x.s2&&y.s1<y.s2) return x.s1<y.s1;
if (x.s1>=x.s2&&y.s1>=y.s2) return x.s2>y.s2;
return false;
}

int max(int x,int y)
{
return x>y?x:y;
}

void Work()
{
sort(ws,ws+n);
int i,t1=0,t2=0;
for (i=0;i<n;i++)
{
t1+=ws.s1;
t2=max(t1,t2)+ws.s2;
}
printf("%dn",t2);
}

void Read()
{
int i;
while (scanf("%d",&n)&&n)
{
for (i=0;i<n;i++)
scanf("%d%d",&ws.s1,&ws.s2);
Work();
}
}

int main()
{
Read();
return 1;
}