某种字符串处理语言允许程序员将一个字符串拆分为两段。由于此操作需要复制字符串，因此要花费n个时间单位来将一个n个字符的字符串拆为两段。假定一个程序员希望将一个字符串拆分为多段，拆分的顺序会影响所花费的总时间。例如，假定这个程序员希望将一个20个字符的字符串在第2个，第8个以及第10个字符后进行拆分(字符由左至右，从1开始升序编号)。如果她按由左到右顺序进行拆分，则第一次拆分花费20个时间单位，第二次拆掉分花费18个时间单位(在第8个字符处拆分3-20间的字符串)而第三次拆分花费12个时间单位，共花费50个时间单位。但如果她按由右至左的顺序进行查分，第一次拆分花费12个时间单位，第二次拆分花费10个时间单位，而第三次拆分花费8个时间单位，共花费38个时间单位。还可以按其他顺序，比如，她可以首先在第8个字符处进行拆分(时间20)，接着在左边一段第2个字符处进行拆分(时间8)，最后在右边一段第10个字符处进行拆分(时间12)，总时间为40.

                  设计算法，对给定的拆分位置，确定最小代价的拆分顺序，更形式化地，给定一个n个字符的字符串S和一个保存m个拆分点的数组L[1..m],计算拆分的最小代价，以及最优拆分序列。

解题思路：字符串拆分可以看做是矩阵链乘法的一个翻版，只是要注意边界条件。字符串拆分要二个拆分点之间必须有一个拆分点才能拆分，cost[i][j]表示从第i个拆分点到第j个拆分点最小花费。那么需要满足j-i>=2条件才可拆分。于是有如下递归式：

递归式：当j-i<=1时 cost[i,j]=0；当j-i>=2时，cost[i,j]=min{cost[i,k]+cost[k,j]+L[j]-L[i]+1}.这样根据递归式，我们可以写出如下代码。

代码如下：

[cpp]
view plain
copy
print
?

1. #include <iostream>  
2. using namespace std;  
3. #define n 7//变更拆分点数目  
4. void BREAK_STRING(int L[],int Break[][n+1])  
5. {//cost[i][j]代表第i个拆分点到第j个拆分点所用的最小花费  
6.    int cost[n+1][n+1]={0},i;  
7.    for (int l=2;l<=n;l++)  
8.    {  
9.        for ( i=1;i<=n-l+1;i++)  
10.        {  
11.            int j=i+l-1;  
12.            if(j-i>=2) cost[i][j]=0x7fffffff;//if(j-i>=2)//这里和矩阵链不同，需要加限制条件。  
13.            for (int k=i+1;k<=j-1;k++)//这里也和矩阵链不同，需要从k=i+1开始  
14.            {  
15.                int temp=cost[i][k]+cost[k][j]+L[j-1]-L[i-1]+1;  
16.                if (temp<cost[i][j])  
17.                {  
18.                    cost[i][j]=temp;  
19.                    Break[i][j]=k;  
20.                }  
21.            }  
22.        }  
23.    }  
24. }  
25. void PRINT_BREAKS(int L[],int Break[][n+1],int i,int j)  
26. {//按照顺序打印拆分点  
27.     if (j-i>=2)  
28.     {//既然是字符串拆分，那么拆分点i与j之间必须还有一个拆分点，所以j-i至少是2  
29.         cout<<L[Break[i][j]-1]<<” ”;  
30.         PRINT_BREAKS(L,Break,i,Break[i][j]);  
31.         PRINT_BREAKS(L,Break,Break[i][j],j);  
32.     }  
33. }  
34. void main()  
35. {   //先对拆分点按照升序排序。  
36.     //int L[n]={1,2,8,10,20},Break[n+1][n+1]={0};//设置开始点为1与结尾点为20，中间三个点2，8，10为拆分点。  
37.     int L[n]={1,11,14,17,20,25,30},Break[n+1][n+1]={0};//设置开始点为1与结尾点为20，中间三个点2，8，10为拆分点。  
38.     BREAK_STRING(L,Break);  
39.     PRINT_BREAKS(L,Break,1,n);  
40. }  

#include <iostream>
using namespace std;

#define n 7//变更拆分点数目 void BREAK_STRING(int L[],int Break[][n+1]) {//cost[i][j]代表第i个拆分点到第j个拆分点所用的最小花费 int cost[n+1][n+1]={0},i; for (int l=2;l<=n;l++) { for ( i=1;i<=n-l+1;i++) { int j=i+l-1; if(j-i>=2) cost[i][j]=0x7fffffff;//if(j-i>=2)//这里和矩阵链不同，需要加限制条件。 for (int k=i+1;k<=j-1;k++)//这里也和矩阵链不同，需要从k=i+1开始 { int temp=cost[i][k]+cost[k][j]+L[j-1]-L[i-1]+1; if (temp<cost[i][j]) { cost[i][j]=temp; Break[i][j]=k; } } } } } void PRINT_BREAKS(int L[],int Break[][n+1],int i,int j) {//按照顺序打印拆分点 if (j-i>=2) {//既然是字符串拆分，那么拆分点i与j之间必须还有一个拆分点，所以j-i至少是2 cout<<L[Break[i][j]-1]<<” “; PRINT_BREAKS(L,Break,i,Break[i][j]); PRINT_BREAKS(L,Break,Break[i][j],j); } } void main() { //先对拆分点按照升序排序。 //int L[n]={1,2,8,10,20},Break[n+1][n+1]={0};//设置开始点为1与结尾点为20，中间三个点2，8，10为拆分点。 int L[n]={1,11,14,17,20,25,30},Break[n+1][n+1]={0};//设置开始点为1与结尾点为20，中间三个点2，8，10为拆分点。 BREAK_STRING(L,Break); PRINT_BREAKS(L,Break,1,n); }

 样例输出：

总结： 和矩阵链乘法一样，都是O(n³)时间，占用O(n²)空间。只要看懂书上矩阵链乘法那节就可以轻松理解这个题目。