动态规划

独立任务最优调度问题

问题描述：

用2台处理机A和B处理n个作业。设第i个作业交给机器A处理时所需要的时间是a[i]，若由机器B来处理，则所需要的时间是b[i]。现在要求每个作业只能由一台机器处理，每台机器都不能同时处理两个作业。设计一个动态规划算法，使得这两台机器处理完这n个作业的时间最短（从任何一台机器开工到最后一台机器停工的总的时间）。研究一个实例：n=6, a = {2, 5, 7, 10, 5, 2}, b = {3, 8, 4, 11, 3, 4}。

编程任务：

对于给定的2台处理机A和B处理n个作业，找出一个最优调度方案，使两台机器处理完这n个作业的时间最短。

数据输入：

由文件input.txt提供输入数据。文件的第1行是1个正整数n，表示要处理n个作业。在接下来的2行中，每行有n个正整数，分别表示处理机A和B处理第i个作业需要的处理时间。

 

分析：当完成k个作业，设机器A花费了x时间，机器B所花费时间的最小值肯定是x的一个函数，设F[k][x]表示机器B所花费时间的最小值。则F[k][x]=Min{ F[k-1][x]+b[k], F[k-1][x-a[k]] }；其中F[k-1][x]+b[k]表示第k个作业由机器B来处理（完成k-1个作业时机器A花费的时间仍是x），F[k-1][x-a[k]]表示第k个作业由机器A处理（完成k-1个作业时机器A花费的时间是x-a[k]）。

那么单个点对较大值Max(x, F[k][x])，表示此时（即机器A花费x时间的情况下）所需要的总时间。而机器A花费的时间x是变化的，即x=0,1,2……x(max)，（理论上x的取值是离散的，但为编程方便，设为整数连续的）由此构成了点对较大值序列。要求整体时间最短，取这些点对较大值序列中最小的即是。理解难点在于B是A的函数表达式，也即动态规划所在。

算法时间复杂度为O(n*Sum)，其中Sum为a中所有元素之和与b中所有元素之和的最小值。

 

public class PlanSchedule { private static final int SIZE = 100; private static final int MAXINT = 999; public void schedule() throws IOException{ int N; String input; BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); input = stdin.readLine(); N = Integer.parseInt(input); if(N<=0) return; int[] a = new int[N+1]; int[] b = new int[N+1]; int[] SumA = new int[N+1]; int[] SumB = new int[N+1]; int tempSumA,tempSumB,MinSum; int i,j,k; tempSumA=tempSumB=0; for(i=1;i<=N;i++){ input = stdin.readLine(); a[i] = Integer.parseInt(input); tempSumA += a[i]; SumA[i]=tempSumA; } for(i=1;i<=N;i++){ input = stdin.readLine(); b[i] = Integer.parseInt(input); tempSumB += b[i]; SumB[i]=tempSumB; } MinSum=(tempSumB>tempSumA)?tempSumA:tempSumB; //时间上限AB总和的最小值 ///动态二维数组 int[] MaxTime = new int[MinSum+1]; int[][] F = new int[N+1][MinSum+1]; SumB[0] = 0; for(i=0;i<=N;i++){ F[i][0]=SumB[i]; for(j=1;j<=MinSum;j++) F[i][j]=0; } int temp; for(k=1;k<=N;k++){ temp = (SumA[k]>SumB[k])?SumB[k]:SumA[k]; for(i=1;i<=temp;i++){ //A最多用AB前k任务的最小值，如果B最少就全用B做 if(i>=a[k]) F[k][i] = min(F[k-1][i]+b[k],F[k-1][i-a[k]]); else F[k][i] = F[k-1][i]+b[k]; } } temp = MAXINT; for(i=0;i<=MinSum;i++){ MaxTime[i] = (i>F[N][i])?i:F[N][i]; if(temp>MaxTime[i]){ temp = MaxTime[i]; } } System.out.println("result:" + temp); } public int min(int a,int b){ return (a>b)?b:a; } public static void main(String[] args) throws IOException { PlanSchedule ps = new PlanSchedule(); while(true){ ps.schedule(); } } }

 

 

编辑距离问题

设A 和B 是2 个字符串。要用最少的字符操作将字符串A 转换为字符串B。这里所说的字符操作包括 (1)删除一个字符； (2)插入一个字符； (3)将一个字符改为另一个字符。将字符串A变换为字符串B 所用的最少字符操作数称为字符串A到B 的编辑距离，记为 d(A,B)。试设计一个有效算法，对任给的2 个字符串A和B，计算出它们的编辑距离d(A,B)。

Input 

  输入的第一行是字符串A，文件的第二行是字符串B。

Output 

  程序运行结束时，将编辑距离d(A,B)输出。

分析：

开一个二维数组d[i][j]来记录a0-ai与b0-bj之间的编辑距离，要递推时，需要考虑对其中一个字符串的删除操作、插入操作和替换操作分别花费的开销，从中找出一个最小的开销即为所求。具体算法：首先给定第一行和第一列，然后，每个值d[i,j]这样计算：

d[i][j]=min(d[i-1][j]+1,d[i][j-1]+1,d[i-1][j-1]+(s1[i]==s2[j]?0:1));最后一行，最后一列的那个值就是最小编辑距离

 

 

public class EditDistance { private String s1; private String s2; private int[][] f; public EditDistance(String s1,String s2){ this.s1 = s1; this.s2 = s2; f = new int[s1.length()][s2.length()]; for(int i=0;i<s1.length();i++){ f[i][0] = i; } for(int j=0;j<s2.length();j++){ f[0][j] = j; } } public int dist(){ for(int i=1;i<s1.length();i++){ for(int j=1;j<s2.length();j++){ int temp=f[i-1][j]+1; if(temp>f[i][j-1]+1) temp = f[i][j-1]+1; if(temp>f[i-1][j-1]+(s1.charAt(i)==s2.charAt(j)?0:1)) temp = f[i-1][j-1]+(s1.charAt(i)==s2.charAt(j)?0:1); f[i][j]=temp; } } return f[s1.length()-1][s2.length()-1]; } public static void main(String[] args) throws IOException { String s1,s2; BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); s1 = stdin.readLine(); s2 = stdin.readLine(); EditDistance d = new EditDistance(s1,s2); int dis = d.dist(); System.out.println(dis); } }