自动换行问题（word wrap problem ）几种解法之比较

问题描述：

给定一个单词序列和一个每行最做可放多少个字符的限制。需要把这个单词序列按限制行宽摆放完，使得每行剩余的空间的成本和最小。

        在同一行不同单词见的空格符不计入剩余的空间。假定某行的剩余空间是N，则其成本是N*N，举例说明之：

假定给定序列为："Geeks for Geeks presents word wrap problem"， 每行宽度限制为15,

则最优的摆放为：

Geeks for Geeks
presents word
wrap problem

剩余空间的成本之和为： 0 + 2 * 2 + 3 * 3;

具体问题的描述可见（www.geeksforgeeks.org)

问题解法：

下面用三种解法给出答案，分别为

1. 暴力搜索；

2. 递归解法；

3. 动态规划；（注：本文的动态规划解法直接来自geeksforgeeks，笔者目前还没找到更简单的动态规划实现）

1，2仅能给出次优解法，他们的策略为贪婪策略；

解决代码：

#ifndef _WORD_WRAP_H_
#define _WORD_WRAP_H_

#include <stdlib.h>
#include <stdio.h>

/*
* The implementation of the method of brute force search for word wrap problem
*
*/
int WordWrapBrute( const int words[], int size, int width )
{
int len = width;
int cost  = 0;
for( int i = 0; i < size; i++ ) // loop each word
{
if( len  >  words[i] )
{
len -= words[i] + 1;
}
else if( len == words[i] )
{
len -= words[i];
}
else if( len < words[i] )
{
if( len > 0 )
cost += ( len + 1 ) * ( len + 1 );

len = width;
len -= words[i] + 1;
}
}

return cost;
}

/*
* The implementation of recursive method for word wrap problem
*
*/
int WordWrapRecur( const int words[], int size, int cur, int rowIdx, int curWidth, int width )
{
if( cur == size )
{
return 0;
}

for( int i = cur; i < size; i++ )
{
if( curWidth - words[i] >= 0 )
{

return  WordWrapRecur( words, size, i + 1, rowIdx,
curWidth - words[i] - 1, width );
}
else
{
rowIdx++;
if( curWidth != 0 )
{
return ( curWidth + 1) * ( curWidth + 1) +

WordWrapRecur( words, size, i + 1, rowIdx,
width - words[i] - 1, width );
}
else
{
return WordWrapRecur( words, size, i + 1, rowIdx,
width - words[i] - 1, width  );
}
}
}
}

/*
* Output solution when apply to dynamic programming method
*
*/

int OutputSolution( int record[], int size )
{
int k = -1;
if( 1 == record[size] )
{
k = 1;
}
else
{
k = OutputSolution( record, record[size] - 1 ) + 1;
}

printf ("Line number %d: From word no. %d to %d \n", k, record[size], size);
return k;
}

/*
* The implementation of dynamic programming for word wrap problem
*
*/
int WordWrapDP( const int words[], int size, int width )
{

// construct table can be used to record the remainder space when from i to j  in single row
int** table = new int*[size + 1];
assert( table );
for( int i = 0; i <= size; i++ )
{
table[i] = new int[ width + 1 ];
assert( table[i] );
}

// calculate i to j remainder space in single row
for( int i = 1; i <= size; i++ )
{
table[i][i] = width - words[i - 1];
for( int j = i + 1; j <= size; j++ )
{
table[i][j] = table[i][j - 1] - words[j-1] - 1;
}
}

// construct cost array
int** cost = new int*[size + 1];
assert( cost );
for( int i = 0; i <= size; i++ )
{
cost[i] = new int[ width + 1 ];
memset( cost[i], 0x00, sizeof(int)*( width + 1) );
assert( cost[i] );
}

for( int i = 1; i <= size; i++ )
{
for( int j = i; j <= size; j++ )
{
if(  table[i][j] < 0 )
{
cost[i][j] = INT_MAX;
}
else if( size == j && table[i][j] >= 0 )
{
cost[i][j] = 0;
}
else
{
cost[i][j] = table[i][j] * table[i][j];
}

}
}

int* result = new int[size + 1];
int* record = new int[size + 1];
memset( record, 0x00, sizeof(int)*(size + 1) );

result[0] = 0;
for( int j = 1; j <= size; j++ )
{
result[j] = INT_MAX;
for( int i = 1; i <= j; i++ )
{
if( result[i - 1] != INT_MAX && cost[i][j] != INT_MAX &&
result[i - 1] + table[i][j] < result[j] )
{
result[j] = result[i - 1] + table[i][j];
record[j] = i;
}
}
}

OutputSolution( record, size );

for( int i = 0; i <= size; i++ )
{
delete [] table[i];
delete [] cost[i];
}

delete [] table;
delete [] cost;

return 0;
}

void TestWordWrap()
{
int words[] = {3, 2, 2, 5};
int size = sizeof(words)/sizeof(words[0]);
int width =  6;

int cost = WordWrapRecur( words, size, 0, 1, 6, 6 );
int newCost = WordWrapBrute( words, size, width );

WordWrapDP( words, size, width );
getchar();

}

#endif