最长公共子序列

设Zk是序列Xm和Yn的最长公共子序列

（1）若zk=xm=yn，则Zk+1是Xm-1和Yn-1的最长公共子序列

（2）若xm≠yn，xm≠zk，则Zk是Xm-1和Yn的最长公共子序列

（3）若xm≠yn，yn≠zk，则Zk是Xm和Yn-1的最长公共子序列

反证即得

def LCS(A,B):
    n=len(A)
    m=len(B)
    A.insert(0,'0')
    B.insert(0,'0')
    #二维表c存放公共子序列的长度
    c=[([0]*(m+1)) for i in range(n+1)]
    #遍历m×n数组
    for i in range(0,n+1):
        for j in range(0,m+1):
            if (i==0 or j==0):
                c[i][j]=0
            elif A[i]==B[j]:
                c[i][j]=c[i-1][j-1]+1
    #max(c[i][j-1],c[i-1][j])
            elif c[i-1][j]>=c[i][j-1]:
                c[i][j]=c[i-1][j]
            else:
                c[i][j]=c[i][j-1]
    return c

加工顺序

如果加工工件i和j满足min（t1j，t2i）≥min（t1i，t2j）不等式，称加工工件i和j满足Bellman's Rule，若任意相邻两个工件均满足，则是最优序列。

（1）在第一台机器M1上的加工视觉越短的工件越先加工

（2）满足在M1上的加工时间小于在第二台机器M2上的加工时间的工件先加工

（3）在M2上的加工时间越短的工件越后加工

因此，满足Bellman's Rule的最优加工顺序的算法步骤设计如下：

（1）令N1={i|t1i<t2i}，N2={i|t1i≥t2i}

（2）将N1中工件按t1i增序排序，将N2中的工件按t2i降序排列

（3）N1+N2

class workpiece:
    def __init__(self,key,id,N1):
        #最短时间
        self.key=key
        #编号
        self.id=id
        #是否在N1
        self.N1=N1
    #重载小于和等于操作
    def __xiaoyu__(self,other):
        return self.key<other.key
    def __dengyu__(self,other):
        return self.key==other.key

def best(n,a,b):
    #记录n个工件workpiece a,b分别为在两台机器上的加工时间
    job=[]
    x=[0 for i in range(n)]#记录最优加工顺序
    for i in range(n):
        if a[i]>b[i]:
            key=b[i]
        else:
            key=a[i]
        N1=a[i]<b[i]
        job.append(workpiece(key,i,N1))
    job.sort()
    j=0
    k=n-1
    for i in range(n):
        if job[1].N1:
            x[j]=job[i].id
            j+=1
        else:
            x[k]=job[i].id
            k-=1
    j=a[x[0]]
    k=j+b[x[0]]
    #计算总时间
    for i in range(1,n):
        j+=a[x[i]]
        if(j<k):
            k=b[x[i]]+k
        else:
            k=j+b[x[i]]
    return x,k