折行算法（word warp）

在英文字处理程序中，由于单词都是由字母序列构成，所以当输入到一行的末尾的时候，就会遇到想要输入的单词长度大于所剩余的空白长度的情况，这就是折行问题。对于手写文本，我们可以用连字符‘-’把单词分割到两行上，但是对于字处理程序而言，其拥有更强的处理能力，可以通过运算来避免单词被分割到两行上。

目前对于文本的折行，比较流行的是贪心算法，也就是尝试在当前行中放下尽可能多的单词，当前行不能再容纳更多单词时，就放到下一行。这样进行折行，对于输入的段落，其折行后的结果，行数最少。对于行宽为6，输入文本"aaa bb cc ddddd"，使用贪心算法生成的折行后结果为：

------

aaa bb

cc

ddddd

在第二行的输入中，发现输入单词'cc'之后，后面只有3个空位（单词之间有一个空格作为分隔符），而下一个单词'ddddd'的长度为5，所以只能将'ddddd'输出到第3行，对于行宽比较小的情况下，贪心算法会造成个别行右侧的空白较大，显得不是很协调。但是对于常用的字处理程序来说，行宽一般为几十，且这些程序在执行折行的同时还会动态调整行内各单词的间距，所以美观问题不是很大。

要实现折行算法，首先需要把输入的字符串分割成一系列单词，GetWords()函数负责实现此功能，将文本中的单词逐个分离出来，添加到单词数组中。该函数实现的功能比较简单，他将空白视为单词的分隔符，如果两个单词之间包含多个空白符号，函数会将其忽略。

void GetWords(const string& text, vector<string>& words_array){string::const_iterator word_begin, word_end;word_begin = word_end = text.begin();while (word_begin != text.end()){if (!isgraph(*word_begin)){++word_begin;++word_end;continue;}if (isgraph(*word_end)){++word_end;}else{words_array.push_back(string(word_begin, word_end));word_begin = word_end;}}}

贪心折行算法以原始文本作为输入，通过GetWords()函数将文本分割为一系列单词，再利用贪心算法对其进行折行处理，在需要折行的地方，函数会加入'\n'（实际的折行算法会在两行之间插入‘软换行’而不是段落标记），最后将执行折行后的文本返回。这里假设所有单词的长度都小于行宽。

string WordWarpGreedy(const string& text, int line_size){int line_space;vector<string>::iterator it;vector<string> words_array;stringstream outstr;GetWords(text, words_array);for (it = words_array.begin(), line_space = line_size;it != words_array.end(); ++it){if ((line_space -= it->length()) >= 0){outstr << (*it);}else{outstr << '\n' << (*it);line_space = line_size - it->length();}if (line_space){outstr << ' ';--line_space;}}return outstr.str();}

这个算法在OpenOffice，Word等字处理软件中被广泛使用。优点就是高效，简单。但是贪心算法也存在不足之处，就是对于一个指定的段落执行折行处理时，贪心算法只会利用当前行的信息，来安排单词，而不会考虑段落内其他行的信息，所以对于某些比较畸形的文本输入，贪心算法产生的某些行，会由于单词安排过少，而出现大量的空白，使文本显得不太协调。

Knuth和Plass提出了一种，更加协调的折行处理算法，这种算法在LaTEX中被使用。

该算法的核心思想是，对于折行后文本的每一行末尾，对由于无法继续安插单词而剩余的空白，计算一个代价值，算法保证，处理后的折行文本的所有行的代价之和最小。以上面的输入文本"aaa bb cc ddddd"为例，第一行剩余的空白为0，第二行剩余的空白为4，第三行剩余的空白为1，如果以空白数的平方作为代价计算公式的话，折行后的总代价和是0^2 + 4^2 + 1^2 = 17。利用Knuth-Plass提出的算法，折行后的输出文本是

------

aaa

bb cc

ddddd

这样，第一行剩余空白是3，第二行的剩余空白是1，第三行的剩余空白是1，折行后总代价值是3^2 + 1^2 + 1^2 = 11，总代价值小于贪心算法的折行结果。

但是对于输入段落，要想求得最小的代价值并不容易，在对段落内容的逐渐扫描中，之前已经安排的单词的位置可能会不断发生变化。如上例，当我们输入完bb时，算法会将bb安排到第1行，此时总代价值为0，当我们输入"cc"之后，如果"bb"还在第一行，则总代价值为4^2 = 16，不是目前的最小代价值，所以算法会将bb移动到第二行，此时的代价总和为3^2 + 1^2 = 10，是当前的最小值。对于行数更多的文本，由于追求最小代价值而导致的级联单词位置调整，可能会很频繁。

Knuth-Plass折行算法，使用了动态规划的思想，当输入单词j的时候，前j个单词所构成的段落的代价最小值f(j)，的计算公式为：

语言描述这个递推式的意思是，当输入单词j时，向前搜索词表中的所有单词，找到满足条件的单词k，将单词k～j安排在最后一行，其他单词位置不动（如果之前有某几个单词在倒数第2行，则将这几个单词移动到最后一行，如前例的'bb'），最后计算出这种安排的总代价和，这个总代价在所有的安排方案中最小。其中的c(i, j)，是代价计算公式，其意义是，将第i到第j个单词安排在一行时，其末尾的空白数的平方，公式如下：

这两个公式均摘自Wiki百科。代价计算公式的P值可以自行决定，一般使用2，3.这个公式有一点需要注意，因为每行的宽度有限，所以如果单词i到j再加上他们之间的分割空白的总长度之和超过行宽时，实际上是无法将这些单词安排在一行的。此时需要返回一组特定的值来表示这种情况。示例为了简单，对于无法将单词i～j安排在一行的情况c(i,j)返回-1，下面是代价计算函数：

inline int CostFunc(const vector<string> words_array, int line_size,unsigned int begin, unsigned int end){unsigned int i;int t, cost;for (i = begin, t = 0; i <= end; ++i){t += words_array[i].length();}cost = line_size - (end - begin) - t;if (cost < 0){return -1;}return cost * cost;}

Knuth-Plass折行算法的实现代码如下：

string WordWarpKnuth(const string& text, int line_size){unsigned int i, j, p;int t, min;vector<string> words_array;stringstream outstr;GetWords(text, words_array);int cost[words_array.size()];int lines[words_array.size()];i = 0;//填充初始在第一行的单词，要防止一行可以容納所有所有情況下的越界while(i < words_array.size() && (t = CostFunc(words_array, line_size, 0, i)) >= 0){cost[i] = t;lines[i++] = 0;}for(;i < words_array.size(); ++i){for(j = i - 1, min = INT_MAX; j > 0; --j){t = CostFunc(words_array, line_size, j + 1, i);if(t >= 0){if(t + cost[j] < min){min = t + cost[j];p = j;}}else{break;}}cost[i] = min;//这里lines[i]保存的是当前单词所处行的上一行的最后一个单词的索引lines[i] = p + 1;}i = words_array.size() - 1;//根据计算结果倒推各单词所处的行的情况while(i > 0){j = lines[i];while(i > j){lines[i--] = j;}if(i == 0){lines[i] = j;}else{lines[i--] = j;}}outstr << words_array[0] << ' ';for(i = 1; i < words_array.size(); ++i){if(lines[i] != lines[i - 1]){outstr << '\n';}outstr << words_array[i] << ' ';}return outstr.str();}

代码的空间复杂度为O(j)，如果提前将段落中所有子单词串的长度和计算出来备用，时间复杂度为O(j^2)。

• 注意程序中的lines数组，记录的是当前单词所在行的上一行的最后一个单词的索引位置，因为在单词不断加入的过程中，折行安排会不断的发生变化，所以用这种方法记录。
• 对于c(i,j)等于-1的情况，说明行宽无法安排Word[i]～Word[j]，用这个值计算最小代价无意义，所以直接舍弃。

对于行宽为25，输入文本"I'm a good guy, and Iknow what I should not to do!"为例，贪心算法的折行结果为：

-------------------------
I'm a good guy, and I
know what I should not to
do!

Knuth-Plass算法的折行结果为：

-------------------------

I'm a good guy,
and I know what I
should not to do!

Knuth-Plass算法的折行结果，比贪心算法更加整齐，对于末行的大片空白，可以通过修正代价值计算方法解决。LaTEX号称最强悍的文本处理程序，绝对不是浪得虚名，而是由很多强悍的技术来支撑的。

当然获得更优美的折行结果是需要代价的，Knuth-Plass算法无论是时间复杂度还是空间复杂度都明显要比贪心算法大很多。而且更重要的是，要实现优美的折行处理，Knuth-Plass算法需要获取整个段落的信息，而在像Word这样的所见即所得字处理程序中，在用户输入段落标记之前，你是无法确切知道这个段落究竟是什么情况的，实时调用Knuth-Plass算法进行折行，代价就比较可观了。Knuth-Plass算法在运行过程中，随着用户的输入，会动态调整各行单词的安排，贪心算法则只会影响当前行的内容，如果用户在输入文本的过程中，发现之前输入的单词“上窜下跳”，估计也是一种比较怪异的使用体验。

所以这个算法只有在像LaTEX这样的编译型字处理程序中，才能大展身手。而且为了简单起见，本文的示例程序，是以字符为单位安排折行的，而在实际的应用中，字母'w'和字母'i'的显示宽度显然是不一样的，所以如果使用像素作为折行的依据，无疑Knuth-Plass算法能够达到更高的境界，这是贪心算法所无法比拟的。