 Open in App
Not now

# Word Wrap Problem | DP-19

• Difficulty Level : Expert
• Last Updated : 13 Jan, 2023

Given a sequence of words, and a limit on the number of characters that can be put in one line (line width). Put line breaks in the given sequence such that the lines are printed neatly. Assume that the length of each word is smaller than the line width.
The word processors like MS Word do task of placing line breaks. The idea is to have balanced lines. In other words, not have few lines with lots of extra spaces and some lines with small amount of extra spaces.

```The extra spaces includes spaces put at the end of every line except the last one.
The problem is to minimize the following total cost.
Cost of a line = (Number of extra spaces in the line)^3
Total Cost = Sum of costs for all lines

For example, consider the following string and line width M = 15
"Geeks for Geeks presents word wrap problem"

Following is the optimized arrangement of words in 3 lines
Geeks for Geeks
presents word
wrap problem

The total extra spaces in line 1, line 2 and line 3 are 0, 2 and 3 respectively.
So optimal value of total cost is 0 + 2*2*2 + 3*3*3 = 35```

Please note that the total cost function is not sum of extra spaces, but sum of cubes (or square is also used) of extra spaces. The idea behind this cost function is to balance the spaces among lines. For example, consider the following two arrangement of same set of words:
1) There are 3 lines. One line has 3 extra spaces and all other lines have 0 extra spaces. Total extra spaces = 3 + 0 + 0 = 3. Total cost = 3*3*3 + 0*0*0 + 0*0*0 = 27.
2) There are 3 lines. Each of the 3 lines has one extra space. Total extra spaces = 1 + 1 + 1 = 3. Total cost = 1*1*1 + 1*1*1 + 1*1*1 = 3.
Total extra spaces are 3 in both scenarios, but second arrangement should be preferred because extra spaces are balanced in all three lines. The cost function with cubic sum serves the purpose because the value of total cost in second scenario is less.

Method 1 (Greedy Solution)
The greedy solution is to place as many words as possible in the first line. Then do the same thing for the second line and so on until all words are placed. This solution gives optimal solution for many cases, but doesn’t give optimal solution in all cases. For example, consider the following string “aaa bb cc ddddd” and line width as 6. Greedy method will produce following output.

```aaa bb
cc
ddddd```

Extra spaces in the above 3 lines are 0, 4 and 1 respectively. So total cost is 0 + 64 + 1 = 65.
But the above solution is not the best solution. Following arrangement has more balanced spaces. Therefore less value of total cost function.

```aaa
bb cc
ddddd```

Extra spaces in the above 3 lines are 3, 1 and 1 respectively. So total cost is 27 + 1 + 1 = 29.
Despite being sub-optimal in some cases, the greedy approach is used by many word processors like MS Word and OpenOffice.org Writer.

Method 2 (Recursive Approach with memoization)

The problem can be solved using a divide and conquer (recursive) approach. The algorithm for the same is mentioned below:

```1. We recur for each word starting with first word, and remaining length of the line (initially k).
2. The last word would be the base case:
We check if we can put it on same line:
if yes, then we return cost as 0.
if no, we return cost of current line based on its remaining length.
3. For non-last words, we have to check if it can fit in the current line:
if yes, then we have two choices i.e. whether to put it in same line or next line.
if we put it on next line: cost1 = square(remLength) + cost of putting word on next line.
if we put it on same line: cost2 = cost of putting word on same line.
return min(cost1, cost2)
if no, then we have to put it on next line:
return cost of putting word on next line
4. We use memoization table of size n (number of words) * k (line length), to keep track of already visited positions.```

## C++

 `#include ``using` `namespace` `std;` `int` `solveWordWrapUsingMemo(``int` `words[], ``int` `n, ``int` `length,``                           ``int` `wordIndex, ``int` `remLength,``                           ``vector > memo);` `int` `square(``int` `n) { ``return` `n * n; }` `int` `solveWordWrapUtil(``int` `words[], ``int` `n, ``int` `length,``                      ``int` `wordIndex, ``int` `remLength,``                      ``vector > memo)``{` `    ``// base case for last word``    ``if` `(wordIndex == n - 1) {``        ``memo[wordIndex][remLength]``            ``= words[wordIndex] < remLength``                  ``? 0``                  ``: square(remLength);``        ``return` `memo[wordIndex][remLength];``    ``}` `    ``int` `currWord = words[wordIndex];``    ``// if word can fit in the remaining line``    ``if` `(currWord < remLength) {``        ``return` `min(solveWordWrapUsingMemo(``                       ``words, n, length, wordIndex + 1,``                       ``remLength == length``                           ``? remLength - currWord``                           ``: remLength - currWord - 1,``                       ``memo),` `                   ``square(remLength)``                       ``+ solveWordWrapUsingMemo(``                           ``words, n, length, wordIndex + 1,``                           ``length - currWord, memo));``    ``}``    ``else` `{``        ``// if word is kept on next line``        ``return` `square(remLength)``               ``+ solveWordWrapUsingMemo(``                   ``words, n, length, wordIndex + 1,``                   ``length - currWord, memo);``    ``}``}` `int` `solveWordWrapUsingMemo(``int` `words[], ``int` `n, ``int` `length,``                           ``int` `wordIndex, ``int` `remLength,``                           ``vector > memo)``{``    ``if` `(memo[wordIndex][remLength] != -1) {``        ``return` `memo[wordIndex][remLength];``    ``}` `    ``memo[wordIndex][remLength] = solveWordWrapUtil(``        ``words, n, length, wordIndex, remLength, memo);``    ``return` `memo[wordIndex][remLength];``}` `int` `solveWordWrap(``int` `words[], ``int` `n, ``int` `k)``{` `    ``vector > memo(n, vector<``int``>(k + 1, -1));` `    ``return` `solveWordWrapUsingMemo(words, n, k, 0, k, memo);``}``int` `main()``{``    ``int` `words[] = { 3, 2, 2, 5 };``    ``int` `n = ``sizeof``(words) / ``sizeof``(words);``    ``int` `k = 6;` `    ``cout << solveWordWrap(words, n, k);``    ``return` `0;``}``/* This Code is contributed by Tapesh (tapeshdua420) */`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;``import` `java.util.Arrays;` `public` `class` `WordWrapDpMemo {` `    ``private` `int` `solveWordWrap(``int``[] nums, ``int` `k) {``        ``int``[][] memo = ``new` `int``[nums.length][k + ``1``];``        ``for` `(``int` `i = ``0``; i < nums.length; i++) {``            ``Arrays.fill(memo[i], -``1``);``        ``}``        ``return` `solveWordWrapUsingMemo(nums, nums.length, k, ``0``, k, memo);``    ``}` `    ``private` `int` `solveWordWrap(``int``[] words, ``int` `n, ``int` `length, ``int` `wordIndex, ``int` `remLength, ``int``[][] memo) {` `        ``//base case for last word``        ``if` `(wordIndex == n - ``1``) {``            ``memo[wordIndex][remLength] = words[wordIndex] < remLength ? ``0` `: square(remLength);``            ``return` `memo[wordIndex][remLength];``        ``}` `        ``int` `currWord = words[wordIndex];``        ``//if word can fit in the remaining line``        ``if` `(currWord < remLength) {``            ``return` `Math.min(``                    ``//if word is kept on same line``                    ``solveWordWrapUsingMemo(words, n, length, wordIndex + ``1``, remLength == length ? remLength - currWord : remLength - currWord - ``1``, memo),``                    ``//if word is kept on next line``                    ``square(remLength) + solveWordWrapUsingMemo(words, n, length, wordIndex + ``1``, length - currWord, memo)``            ``);``        ``} ``else` `{``            ``//if word is kept on next line``            ``return` `square(remLength) + solveWordWrapUsingMemo(words, n, length, wordIndex + ``1``, length - currWord, memo);``        ``}``    ``}` `    ``private` `int` `solveWordWrapUsingMemo(``int``[] words, ``int` `n, ``int` `length, ``int` `wordIndex, ``int` `remLength, ``int``[][] memo) {``        ``if` `(memo[wordIndex][remLength] != -``1``) {``            ``return` `memo[wordIndex][remLength];``        ``}` `        ``memo[wordIndex][remLength] = solveWordWrap(words, n, length, wordIndex, remLength, memo);``        ``return` `memo[wordIndex][remLength];``    ``}` `    ``private` `int` `square(``int` `n) {``        ``return` `n * n;``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``System.out.println(``new` `WordWrapDpMemo().solveWordWrap(``new` `int``[]{``3``, ``2``, ``2``, ``5``}, ``6``));``    ``}``}`

## Python3

 `# Python program for the above approach``def` `square(n) :``    ``return` `n ``*` `n`` ` `def` `solveWordWrapUtil(words, n, length,``                      ``wordIndex, remLength, memo) :`` ` `    ``# base case for last word``    ``if` `(wordIndex ``=``=` `n ``-` `1``) :``        ``memo[wordIndex][remLength] ``=` `0` `if` `(words[wordIndex] < remLength) ``else` `square(remLength)``        ``return` `memo[wordIndex][remLength]``    ` ` ` `    ``currWord ``=` `words[wordIndex]``    ``# if word can fit in the remaining line``    ``if` `(currWord < remLength) :``        ``return` `min``(solveWordWrapUsingMemo(``                       ``words, n, length, wordIndex ``+` `1``,``                       ``remLength ``-` `currWord ``if` `(remLength ``=``=` `length) ``else` `remLength ``-` `currWord ``-` `1``,``                       ``memo),`` ` `                   ``square(remLength)``                       ``+` `solveWordWrapUsingMemo(``                           ``words, n, length, wordIndex ``+` `1``,``                           ``length ``-` `currWord, memo))``    ` `    ``else` `:``        ``# if word is kept on next line``        ``return` `(square(remLength)``               ``+` `solveWordWrapUsingMemo(``                   ``words, n, length, wordIndex ``+` `1``,``                   ``length ``-` `currWord, memo))``    ` `def` `solveWordWrapUsingMemo(words, n, length,``                           ``wordIndex, remLength, memo) :``                               ` `    ``if` `(memo[wordIndex][remLength] !``=` `-``1``) :``        ``return` `memo[wordIndex][remLength]``    ` `    ``memo[wordIndex][remLength] ``=` `(solveWordWrapUtil(``        ``words, n, length, wordIndex, remLength, memo))``    ``return` `memo[wordIndex][remLength]` `def` `solveWordWrap(words, n, k) :``    ``memo ``=` `[[``10``]``*` `(k ``+` `1``)]``*` `n``    ``return` `solveWordWrapUsingMemo(words, n, k, ``0``, k, memo)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``words ``=` `[ ``3``, ``2``, ``2``, ``5` `]``    ``n ``=` `len``(words)``    ``k ``=` `6`` ` `    ``print``(solveWordWrap(words, n, k))``    ` `# This code is contributed by sanjoy_62.`

## C#

 `/*package whatever //do not write package name here */``using` `System;``using` `System.Collections.Generic;` `public` `class` `WordWrapDpMemo {` `    ``private` `int` `solveWordWrap(``int``[] nums, ``int` `k)``    ``{``        ``int``[,] memo = ``new` `int``[nums.Length ,k + 1];``        ``for` `(``int` `i = 0; i < memo.GetLength(0); i++)``        ``{``            ``for``(``int` `j = 0; j < memo.GetLength(1); j++)``            ``memo[i, j] = -1;``        ``}``        ``return` `solveWordWrapUsingMemo(nums, nums.Length,``                                      ``k, 0, k, memo);``    ``}` `    ``private` `int` `solveWordWrap(``int``[] words, ``int` `n,``                              ``int` `length, ``int` `wordIndex,``                              ``int` `remLength, ``int``[,] memo)``    ``{` `        ``// base case for last word``        ``if` `(wordIndex == n - 1) {``            ``memo[wordIndex, remLength] = words[wordIndex] <``              ``remLength ? 0 : square(remLength);``            ``return` `memo[wordIndex, remLength];``        ``}` `        ``int` `currWord = words[wordIndex];``      ` `        ``// if word can fit in the remaining line``        ``if` `(currWord < remLength) {``            ``return` `Math.Min(``              ` `                    ``// if word is kept on same line``                    ``solveWordWrapUsingMemo(words, n, length, wordIndex + 1,``                            ``remLength == length ? remLength -``                                           ``currWord : remLength -``                                           ``currWord - 1, memo),``                    ` `              ``// if word is kept on next line``                    ``square(remLength)``                            ``+ solveWordWrapUsingMemo(words, n,``                                                     ``length,``                                                     ``wordIndex + 1,``                                                     ``length - currWord,``                                                     ``memo));``        ``} ``else` `{``            ``// if word is kept on next line``            ``return` `square(remLength) +``              ``solveWordWrapUsingMemo(words, n, length,``                                     ``wordIndex + 1,``                                     ``length - currWord, memo);``        ``}``    ``}` `    ``private` `int` `solveWordWrapUsingMemo(``int``[] words, ``int` `n,``                                       ``int` `length, ``int` `wordIndex,``                                       ``int` `remLength, ``int``[,] memo)``    ``{``        ``if` `(memo[wordIndex,remLength] != -1)``        ``{``            ``return` `memo[wordIndex,remLength];``        ``}` `        ``memo[wordIndex,remLength] = solveWordWrap(words,``                                                  ``n, length,``                                                  ``wordIndex,``                                                  ``remLength, memo);``        ``return` `memo[wordIndex, remLength];``    ``}` `    ``private` `int` `square(``int` `n) {``        ``return` `n * n;``    ``}` `    ``public` `static` `void` `Main(String[] args) {``        ``Console.WriteLine(``new` `WordWrapDpMemo().``                          ``solveWordWrap(``new` `int``[] { 3, 2, 2, 5 }, 6));``    ``}``}` `// This code is contributed by gauravrajput1`

## Javascript

 ``

Output

`10`

Method 3 (Dynamic Programming)
The following Dynamic approach strictly follows the algorithm given in solution of Cormen book. First we compute costs of all possible lines in a 2D table lc[][]. The value lc[i][j] indicates the cost to put words from i to j in a single line where i and j are indexes of words in the input sequences. If a sequence of words from i to j cannot fit in a single line, then lc[i][j] is considered infinite (to avoid it from being a part of the solution). Once we have the lc[][] table constructed, we can calculate total cost using following recursive formula. In the following formula, C[j] is the optimized total cost for arranging words from 1 to j. The above recursion has overlapping subproblem property. For example, the solution of subproblem c(2) is used by c(3), C(4) and so on. So Dynamic Programming is used to store the results of subproblems. The array c[] can be computed from left to right, since each value depends only on earlier values.
To print the output, we keep track of what words go on what lines, we can keep a parallel p array that points to where each c value came from. The last line starts at word p[n] and goes through word n. The previous line starts at word p[p[n]] and goes through word p[n] – 1, etc. The function printSolution() uses p[] to print the solution.
In the below program, input is an array l[] that represents lengths of words in a sequence. The value l[i] indicates length of the ith word (i starts from 1) in theinput sequence.

## C++

 `// A Dynamic programming solution for Word Wrap Problem``#include ``using` `namespace` `std;``#define INF INT_MAX` `// A utility function to print the solution``int` `printSolution (``int` `p[], ``int` `n);` `// l[] represents lengths of different words in input sequence.``// For example, l[] = {3, 2, 2, 5} is for a sentence like``// "aaa bb cc ddddd". n is size of l[] and M is line width``// (maximum no. of characters that can fit in a line)``void` `solveWordWrap (``int` `l[], ``int` `n, ``int` `M)``{``    ``// For simplicity, 1 extra space is used in all below arrays` `    ``// extras[i][j] will have number of extra spaces if words from i``    ``// to j are put in a single line``    ``int` `extras[n+1][n+1];` `    ``// lc[i][j] will have cost of a line which has words from``    ``// i to j``    ``int` `lc[n+1][n+1];` `    ``// c[i] will have total cost of optimal arrangement of words``    ``// from 1 to i``    ``int` `c[n+1];` `    ``// p[] is used to print the solution.``    ``int` `p[n+1];` `    ``int` `i, j;` `    ``// calculate extra spaces in a single line. The value extra[i][j]``    ``// indicates extra spaces if words from word number i to j are``    ``// placed in a single line``    ``for` `(i = 1; i <= n; i++)``    ``{``        ``extras[i][i] = M - l[i-1];``        ``for` `(j = i+1; j <= n; j++)``            ``extras[i][j] = extras[i][j-1] - l[j-1] - 1;``    ``}` `    ``// Calculate line cost corresponding to the above calculated extra``    ``// spaces. The value lc[i][j] indicates cost of putting words from``    ``// word number i to j in a single line``    ``for` `(i = 1; i <= n; i++)``    ``{``        ``for` `(j = i; j <= n; j++)``        ``{``            ``if` `(extras[i][j] < 0)``                ``lc[i][j] = INF;``            ``else` `if` `(j == n && extras[i][j] >= 0)``                ``lc[i][j] = 0;``            ``else``                ``lc[i][j] = extras[i][j]*extras[i][j];``        ``}``    ``}` `    ``// Calculate minimum cost and find minimum cost arrangement.``    ``// The value c[j] indicates optimized cost to arrange words``    ``// from word number 1 to j.``    ``c = 0;``    ``for` `(j = 1; j <= n; j++)``    ``{``        ``c[j] = INF;``        ``for` `(i = 1; i <= j; i++)``        ``{``            ``if` `(c[i-1] != INF && lc[i][j] != INF &&``                           ``(c[i-1] + lc[i][j] < c[j]))``            ``{``                ``c[j] = c[i-1] + lc[i][j];``                ``p[j] = i;``            ``}``        ``}``    ``}` `    ``printSolution(p, n);``}` `int` `printSolution (``int` `p[], ``int` `n)``{``    ``int` `k;``    ``if` `(p[n] == 1)``        ``k = 1;``    ``else``        ``k = printSolution (p, p[n]-1) + 1;``    ``cout<<``"Line number "``<

## C

 `// A Dynamic programming solution for Word Wrap Problem``#include ``#include ``#define INF INT_MAX` `// A utility function to print the solution``int` `printSolution (``int` `p[], ``int` `n);` `// l[] represents lengths of different words in input sequence.``// For example, l[] = {3, 2, 2, 5} is for a sentence like``// "aaa bb cc ddddd". n is size of l[] and M is line width``// (maximum no. of characters that can fit in a line)``void` `solveWordWrap (``int` `l[], ``int` `n, ``int` `M)``{``    ``// For simplicity, 1 extra space is used in all below arrays` `    ``// extras[i][j] will have number of extra spaces if words from i``    ``// to j are put in a single line``    ``int` `extras[n+1][n+1]; ` `    ``// lc[i][j] will have cost of a line which has words from``    ``// i to j``    ``int` `lc[n+1][n+1];`` ` `    ``// c[i] will have total cost of optimal arrangement of words``    ``// from 1 to i``    ``int` `c[n+1];` `    ``// p[] is used to print the solution. ``    ``int` `p[n+1];` `    ``int` `i, j;` `    ``// calculate extra spaces in a single line.  The value extra[i][j]``    ``// indicates extra spaces if words from word number i to j are``    ``// placed in a single line``    ``for` `(i = 1; i <= n; i++)``    ``{``        ``extras[i][i] = M - l[i-1];``        ``for` `(j = i+1; j <= n; j++)``            ``extras[i][j] = extras[i][j-1] - l[j-1] - 1;``    ``}` `    ``// Calculate line cost corresponding to the above calculated extra``    ``// spaces. The value lc[i][j] indicates cost of putting words from``    ``// word number i to j in a single line``    ``for` `(i = 1; i <= n; i++)``    ``{``        ``for` `(j = i; j <= n; j++)``        ``{``            ``if` `(extras[i][j] < 0)``                ``lc[i][j] = INF;``            ``else` `if` `(j == n && extras[i][j] >= 0)``                ``lc[i][j] = 0;``            ``else``                ``lc[i][j] = extras[i][j]*extras[i][j];``        ``}``    ``}` `    ``// Calculate minimum cost and find minimum cost arrangement.``    ``//  The value c[j] indicates optimized cost to arrange words``    ``// from word number 1 to j.``    ``c = 0;``    ``for` `(j = 1; j <= n; j++)``    ``{``        ``c[j] = INF;``        ``for` `(i = 1; i <= j; i++)``        ``{``            ``if` `(c[i-1] != INF && lc[i][j] != INF &&``               ``(c[i-1] + lc[i][j] < c[j]))``            ``{``                ``c[j] = c[i-1] + lc[i][j];``                ``p[j] = i;``            ``}``        ``}``    ``}` `    ``printSolution(p, n);``}` `int` `printSolution (``int` `p[], ``int` `n)``{``    ``int` `k;``    ``if` `(p[n] == 1)``        ``k = 1;``    ``else``        ``k = printSolution (p, p[n]-1) + 1;``    ``printf` `(``"Line number %d: From word no. %d to %d \n"``, k, p[n], n);``    ``return` `k;``}` `// Driver program to test above functions``int` `main()``{``    ``int` `l[] = {3, 2, 2, 5};``    ``int` `n = ``sizeof``(l)/``sizeof``(l);``    ``int` `M = 6;``    ``solveWordWrap (l, n, M);``    ``return` `0;``}`

## Java

 `// A Dynamic programming solution for``// Word Wrap Problem in Java``public` `class` `WordWrap``{` `    ``final` `int` `MAX = Integer.MAX_VALUE;``    ` `    ``// A utility function to print the solution``    ``int` `printSolution (``int` `p[], ``int` `n)``    ``{``        ``int` `k;``        ``if` `(p[n] == ``1``)``        ``k = ``1``;``        ``else``        ``k = printSolution (p, p[n]-``1``) + ``1``;``        ``System.out.println(``"Line number"` `+ ``" "` `+ k + ``": "` `+``                    ``"From word no."` `+``" "``+ p[n] + ``" "` `+ ``"to"` `+ ``" "` `+ n);``        ``return` `k;``    ``}` `// l[] represents lengths of different words in input sequence.``// For example, l[] = {3, 2, 2, 5} is for a sentence like``// "aaa bb cc ddddd". n is size of l[] and M is line width``// (maximum no. of characters that can fit in a line)``    ``void` `solveWordWrap (``int` `l[], ``int` `n, ``int` `M)``    ``{``        ``// For simplicity, 1 extra space is used in all below arrays``    ` `        ``// extras[i][j] will have number of extra spaces if words from i``        ``// to j are put in a single line``        ``int` `extras[][] = ``new` `int``[n+``1``][n+``1``];``    ` `        ``// lc[i][j] will have cost of a line which has words from``        ``// i to j``        ``int` `lc[][]= ``new` `int``[n+``1``][n+``1``];``    ` `        ``// c[i] will have total cost of optimal arrangement of words``        ``// from 1 to i``        ``int` `c[] = ``new` `int``[n+``1``];``    ` `        ``// p[] is used to print the solution.``        ``int` `p[] =``new` `int``[n+``1``];``    ` `        ``// calculate extra spaces in a single line. The value extra[i][j]``        ``// indicates extra spaces if words from word number i to j are``        ``// placed in a single line``        ``for` `(``int` `i = ``1``; i <= n; i++)``        ``{``            ``extras[i][i] = M - l[i-``1``];``            ``for` `(``int` `j = i+``1``; j <= n; j++)``            ``extras[i][j] = extras[i][j-``1``] - l[j-``1``] - ``1``;``        ``}``        ` `        ``// Calculate line cost corresponding to the above calculated extra``        ``// spaces. The value lc[i][j] indicates cost of putting words from``        ``// word number i to j in a single line``        ``for` `(``int` `i = ``1``; i <= n; i++)``        ``{``            ``for` `(``int` `j = i; j <= n; j++)``            ``{``                ``if` `(extras[i][j] < ``0``)``                    ``lc[i][j] = MAX;``                ``else` `if` `(j == n && extras[i][j] >= ``0``)``                    ``lc[i][j] = ``0``;``                ``else``                    ``lc[i][j] = extras[i][j]*extras[i][j];``            ``}``        ``}``        ` `        ``// Calculate minimum cost and find minimum cost arrangement.``        ``// The value c[j] indicates optimized cost to arrange words``        ``// from word number 1 to j.``        ``c[``0``] = ``0``;``        ``for` `(``int` `j = ``1``; j <= n; j++)``        ``{``            ``c[j] = MAX;``            ``for` `(``int` `i = ``1``; i <= j; i++)``            ``{``                ``if` `(c[i-``1``] != MAX && lc[i][j] != MAX &&``                   ``(c[i-``1``] + lc[i][j] < c[j]))``                ``{``                    ``c[j] = c[i-``1``] + lc[i][j];``                    ``p[j] = i;``                ``}``            ``}``        ``}``    ` `        ``printSolution(p, n);``    ``}` `    ``public` `static` `void` `main(String args[])``    ``{``        ``WordWrap w = ``new` `WordWrap();``        ``int` `l[] = {``3``, ``2``, ``2``, ``5``};``        ``int` `n = l.length;``        ``int` `M = ``6``;``        ``w.solveWordWrap (l, n, M);``    ``}``}` `// This code is contributed by Saket Kumar`

## Python3

 `# A Dynamic programming solution``# for Word Wrap Problem` `# A utility function to print``# the solution``# l[] represents lengths of different``# words in input sequence. For example,``# l[] = {3, 2, 2, 5} is for a sentence``# like "aaa bb cc ddddd". n is size of``# l[] and M is line width (maximum no.``# of characters that can fit in a line)``INF ``=` `2147483647``def` `printSolution(p, n):``    ``k ``=` `0``    ``if` `p[n] ``=``=` `1``:``        ``k ``=` `1``    ``else``:``        ``k ``=` `printSolution(p, p[n] ``-` `1``) ``+` `1``    ``print``(``'Line number '``, k, ``': From word no. '``,``                                 ``p[n], ``'to '``, n)``    ``return` `k` `def` `solveWordWrap (l, n, M):``    ` `    ``# For simplicity, 1 extra space is``    ``# used in all below arrays` `    ``# extras[i][j] will have number``    ``# of extra spaces if words from i``    ``# to j are put in a single line``    ``extras ``=` `[[``0` `for` `i ``in` `range``(n ``+` `1``)]``                 ``for` `i ``in` `range``(n ``+` `1``)]``                 ` `    ``# lc[i][j] will have cost of a line``    ``# which has words from i to j``    ``lc ``=` `[[``0` `for` `i ``in` `range``(n ``+` `1``)]``             ``for` `i ``in` `range``(n ``+` `1``)]``             ` `    ``# c[i] will have total cost of``    ``# optimal arrangement of words``    ``# from 1 to i``    ``c ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)]``    ` `    ``# p[] is used to print the solution.``    ``p ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)]``    ` `    ``# calculate extra spaces in a single``    ``# line. The value extra[i][j] indicates``    ``# extra spaces if words from word number``    ``# i to j are placed in a single line``    ``for` `i ``in` `range``(n ``+` `1``):``        ``extras[i][i] ``=` `M ``-` `l[i ``-` `1``]``        ``for` `j ``in` `range``(i ``+` `1``, n ``+` `1``):``            ``extras[i][j] ``=` `(extras[i][j ``-` `1``] ``-``                                    ``l[j ``-` `1``] ``-` `1``)``                                    ` `    ``# Calculate line cost corresponding``    ``# to the above calculated extra``    ``# spaces. The value lc[i][j] indicates``    ``# cost of putting words from word number``    ``# i to j in a single line``    ``for` `i ``in` `range``(n ``+` `1``):``        ``for` `j ``in` `range``(i, n ``+` `1``):``            ``if` `extras[i][j] < ``0``:``                ``lc[i][j] ``=` `INF;``            ``elif` `j ``=``=` `n ``and` `extras[i][j] >``=` `0``:``                ``lc[i][j] ``=` `0``            ``else``:``                ``lc[i][j] ``=` `(extras[i][j] ``*``                            ``extras[i][j])` `    ``# Calculate minimum cost and find``    ``# minimum cost arrangement. The value``    ``# c[j] indicates optimized cost to``    ``# arrange words from word number 1 to j.``    ``c[``0``] ``=` `0``    ``for` `j ``in` `range``(``1``, n ``+` `1``):``        ``c[j] ``=` `INF``        ``for` `i ``in` `range``(``1``, j ``+` `1``):``            ``if` `(c[i ``-` `1``] !``=` `INF ``and``                ``lc[i][j] !``=` `INF ``and``                ``((c[i ``-` `1``] ``+` `lc[i][j]) < c[j])):``                ``c[j] ``=` `c[i``-``1``] ``+` `lc[i][j]``                ``p[j] ``=` `i``    ``printSolution(p, n)``    ` `# Driver Code``l ``=` `[``3``, ``2``, ``2``, ``5``]``n ``=` `len``(l)``M ``=` `6``solveWordWrap(l, n, M)` `# This code is contributed by sahil shelangia`

## C#

 `// A Dynamic programming solution for Word Wrap``// Problem in Java``using` `System;` `public` `class` `GFG {` `    ``static` `int` `MAX = ``int``.MaxValue;``    ` `    ``// A utility function to print the solution``    ``static` `int` `printSolution (``int` `[]p, ``int` `n)``    ``{``        ``int` `k;``        ` `        ``if` `(p[n] == 1)``            ``k = 1;``        ``else``            ``k = printSolution (p, p[n]-1) + 1;``            ` `        ``Console.WriteLine(``"Line number"` `+ ``" "``                ``+ k + ``": From word no."` `+ ``" "``                ``+ p[n] + ``" "` `+ ``"to"` `+ ``" "` `+ n);``        ``return` `k;``    ``}` `    ``// l[] represents lengths of different``    ``// words in input sequence. For example,``    ``// l[] = {3, 2, 2, 5} is for a sentence``    ``// like "aaa bb cc ddddd". n is size of``    ``// l[] and M is line width (maximum no.``    ``// of characters that can fit in a line)``    ``static` `void` `solveWordWrap (``int` `[]l, ``int` `n,``                                        ``int` `M)``    ``{``        ` `        ``// For simplicity, 1 extra space``        ``// is used in all below arrays``    ` `        ``// extras[i][j] will have number of``        ``// extra spaces if words from i``        ``// to j are put in a single line``        ``int` `[,]extras = ``new` `int``[n+1,n+1];``    ` `        ``// lc[i][j] will have cost of a line``        ``// which has words from i to j``        ``int` `[,]lc = ``new` `int``[n+1,n+1];``    ` `        ``// c[i] will have total cost of``        ``// optimal arrangement of words``        ``// from 1 to i``        ``int` `[]c = ``new` `int``[n+1];``    ` `        ``// p[] is used to print the solution.``        ``int` `[]p = ``new` `int``[n+1];``    ` `        ``// calculate extra spaces in a single``        ``// line. The value extra[i][j] indicates``        ``// extra spaces if words from word number``        ``// i to j are placed in a single line``        ``for` `(``int` `i = 1; i <= n; i++)``        ``{``            ``extras[i,i] = M - l[i-1];``            ` `            ``for` `(``int` `j = i+1; j <= n; j++)``                ``extras[i,j] = extras[i,j-1]``                                 ``- l[j-1] - 1;``        ``}``        ` `        ``// Calculate line cost corresponding to``        ``// the above calculated extra spaces. The``        ``// value lc[i][j] indicates cost of``        ``// putting words from word number i to``        ``// j in a single line``        ``for` `(``int` `i = 1; i <= n; i++)``        ``{``            ``for` `(``int` `j = i; j <= n; j++)``            ``{``                ``if` `(extras[i,j] < 0)``                    ``lc[i,j] = MAX;``                ``else` `if` `(j == n &&``                              ``extras[i,j] >= 0)``                    ``lc[i,j] = 0;``                ``else``                    ``lc[i,j] = extras[i,j]``                                 ``* extras[i,j];``            ``}``        ``}``        ` `        ``// Calculate minimum cost and find``        ``// minimum cost arrangement. The value``        ``// c[j] indicates optimized cost to``        ``// arrange words from word number``        ``// 1 to j.``        ``c = 0;``        ``for` `(``int` `j = 1; j <= n; j++)``        ``{``            ``c[j] = MAX;``            ``for` `(``int` `i = 1; i <= j; i++)``            ``{``                ``if` `(c[i-1] != MAX && lc[i,j]``                    ``!= MAX && (c[i-1] + lc[i,j]``                                       ``< c[j]))``                ``{``                    ``c[j] = c[i-1] + lc[i,j];``                    ``p[j] = i;``                ``}``            ``}``        ``}``    ` `        ``printSolution(p, n);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `[]l = {3, 2, 2, 5};``        ``int` `n = l.Length;``        ``int` `M = 6;``        ``solveWordWrap (l, n, M);``    ``}``}` `// This code is contributed by nitin mittal.`

## Javascript

 ``

Output

```Line number 1: From word no. 1 to 1
Line number 2: From word no. 2 to 3
Line number 3: From word no. 4 to 4```

Time Complexity: O(n^2)
Auxiliary Space: O(n^2) The auxiliary space used in the above program can be optimized to O(n) (See the reference 2 for details)

#### Method 4

The following approach further lowers the space complexity of algorithm.

## C++

 `#include ``using` `namespace` `std;` `void` `solveWordWrap(``int` `n , ``int` `arr[], ``int` `k){``  ``//initialize total cost``    ``int` `total_cost = 0;``    ``for``(``int` `i = 0; i < n - 1; i++){``      ``//size of window left after the current element``        ``int` `size = k - 1 - arr[i];``      ``//cost of current line``        ``int` `sum = k - arr[i];``        ``while``(size >= 0){``            ``size = size - arr[i+1] - 1;``          ``// breaks immediately``            ``if``(size < 0){``break``;}``            ``sum = sum - arr[i] - 1;``            ``i++;``        ``}``      ``//add current cost to total cost``        ``total_cost = total_cost + (sum*sum);``    ``}``  ``//print the total cost``    ``cout << total_cost;``}` `int` `main(){``    ``int` `n = 4;``    ``int` `nums[n] = {3,2,2,5};``    ``int` `k = 6;``    ``solveWordWrap(n, nums, k);``}``// this code is contributed by Sanyam Jain`

## Java

 `import` `java.util.*;` `class` `GFG {``  ``static` `void` `solveWordWrap(``int` `n, ``int` `arr[], ``int` `k)``  ``{` `    ``// initialize total cost``    ``int` `total_cost = ``0``;``    ``for` `(``int` `i = ``0``; i < n - ``1``; i++)``    ``{` `      ``// size of window left after the current element``      ``int` `size = k - ``1` `- arr[i];` `      ``// cost of current line``      ``int` `sum = k - arr[i];``      ``while` `(size >= ``0``)``      ``{``        ``size = size - arr[i + ``1``] - ``1``;` `        ``// breaks immediately``        ``if` `(size < ``0``) {``          ``break``;``        ``}``        ``sum = sum - arr[i] - ``1``;``        ``i++;``      ``}` `      ``// add current cost to total cost``      ``total_cost = total_cost + (sum * sum);``    ``}` `    ``// print the total cost``    ``System.out.println(total_cost);``  ``}``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `n = ``4``;``    ``int``[] nums = { ``3``, ``2``, ``2``, ``5` `};``    ``int` `k = ``6``;``    ``solveWordWrap(n, nums, k);``  ``}``}` `// This code is contributed by karandeep1234.`

## Python3

 `def` `solveWordWrap(n, arr, k):``    ``# initialize total cost``    ``total_cost ``=` `0``    ``for` `i ``in` `range``(n``-``2``):``        ``# size of window left after the current element``        ``size ``=` `k ``-` `1` `-` `arr[i]``        ``# cost of current line``        ``sum` `=` `k ``-` `arr[i]``        ``while``(size >``=` `0``):``            ``size ``=` `size ``-` `arr[i``+``1``] ``-` `1``            ``# breaks immediately``            ``if``(size < ``0``):``                ``break``            ``sum` `=` `sum` `-` `arr[i] ``-` `1``            ``i ``=` `i``+``1` `        ``# add current cost to total cost``        ``total_cost ``=` `total_cost ``+` `(``sum``*``sum``)` `    ``# print the total cost``    ``print``(total_cost)`  `n ``=` `4``nums ``=` `[``3``, ``2``, ``2``, ``5``]``k ``=` `6``solveWordWrap(n, nums, k)` `# This code is contributed by garg28harsh.`

## C#

 `using` `System;` `class` `GFG {``  ``static` `void` `solveWordWrap(``int` `n, ``int``[] arr, ``int` `k)``  ``{` `    ``// initialize total cost``    ``int` `total_cost = 0;``    ``for` `(``int` `i = 0; i < n - 1; i++) {` `      ``// size of window left after the current element``      ``int` `size = k - 1 - arr[i];` `      ``// cost of current line``      ``int` `sum = k - arr[i];``      ``while` `(size >= 0) {``        ``size = size - arr[i + 1] - 1;` `        ``// breaks immediately``        ``if` `(size < 0) {``          ``break``;``        ``}``        ``sum = sum - arr[i] - 1;``        ``i++;``      ``}` `      ``// add current cost to total cost``      ``total_cost = total_cost + (sum * sum);``    ``}` `    ``// print the total cost``    ``Console.WriteLine(total_cost);``  ``}``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int` `n = 4;``    ``int``[] nums = { 3, 2, 2, 5 };``    ``int` `k = 6;``    ``solveWordWrap(n, nums, k);``  ``}``}` `// This code is contributed by karandeep1234.`

## Javascript

 `   ``// JavaScript code for the above approach``   ``function` `solveWordWrap(n, arr, k)``   ``{``   ` `     ``// initialize total cost``     ``let total_cost = 0;``     ``for` `(let i = 0; i < n - 1; i++)``     ``{``       ``// size of window left after the current element``       ``let size = k - 1 - arr[i];``       ` `       ``// cost of current line``       ``let sum = k - arr[i];``       ``while` `(size >= 0)``       ``{``       ` `         ``size = size - arr[i + 1] - 1;``         ` `         ``// breaks immediately``         ``if` `(size < 0) { ``break``; }``         ``sum = sum - arr[i] - 1;``         ``i++;``       ``}``       ` `       ``// add current cost to total cost``       ``total_cost = total_cost + (sum * sum);``     ``}``     ` `     ``// print the total cost``     ``console.log(total_cost);``   ``}` `   ``let n = 4;``   ``let nums = [3, 2, 2, 5];``   ``let k = 6;``   ``solveWordWrap(n, nums, k);` `// This code is contributed by Potta Lokesh`

Output

`10`

Time Complexity: O(n^2)
Auxiliary Space: O(1)(constant)

Word Wrap problem ( Space optimized solution )
References:
http://en.wikipedia.org/wiki/Word_wrap