Leetcode: Sentence Screen Fitting

Given a rows x cols screen and a sentence represented by a list of words, find how many times the given sentence can be fitted on the screen.

Note:

A word cannot be split into two lines.
The order of words in the sentence must remain unchanged.
Two consecutive words in a line must be separated by a single space.
Total words in the sentence won't exceed 100.
Length of each word won't exceed 10.
1 ≤ rows, cols ≤ 20,000.
Example 1:

Input:
rows = 2, cols = 8, sentence = ["hello", "world"]

Output:
1

Explanation:
hello---
world---

The character '-' signifies an empty space on the screen.
Example 2:

Input:
rows = 3, cols = 6, sentence = ["a", "bcd", "e"]

Output:
2

Explanation:
a-bcd-
e-a---
bcd-e-

The character '-' signifies an empty space on the screen.
Example 3:

Input:
rows = 4, cols = 5, sentence = ["I", "had", "apple", "pie"]

Output:
1

Explanation:
I-had
apple
pie-I
had--

The character '-' signifies an empty space on the screen.

先来一个brute force, 类似Text Adjustment

 public class Solution {
     public int wordsTyping(String[] sentence, int rows, int cols) {
         if (sentence==null || sentence.length==0 || sentence.length>rows*cols || rows<=0 || cols<=0)
             return 0;
         int res = 0;
         int j = 0; //indicate the index of string in sentence that is currently trying to be inserted to current row
         int row = 0; //current row
         int col = 0; //current col

         while (row < rows) {
             while (col + sentence[j].length() - 1 < cols) {
                 col = col + sentence[j].length() + 1;
                 j++;
                 if (j == sentence.length) {
                     res++;
                     j = 0;
                 }
             }
             row++;
             col = 0;
         }
         return res;
     }
 }

但是在稍微大一点的case就TLE了，比如：

["a","b","e"] 20000 20000， 花了465ms

所以想想怎么节约时间，

提示是可以DP的，想想怎么复用，refer to: https://discuss.leetcode.com/topic/62364/java-optimized-solution-17ms

如果这一行由sentence里面某一个string开头，那么，下一行由哪个string开头，这个是确定的；同时，本行会不会到达sentence末尾，如果会，到几次，这个也是一定的

这两点就可以加以利用，因为我们找到了DP的复用关系

sub-problem: if there's a new line which is starting with certain index in sentence, what is the starting index of next line (nextIndex[]). BTW, we compute how many times the pointer in current line passes over the last index (times[]).

Time complexity : O(n*(cols/lenAverage)) + O(rows), where n is the length of sentence array, lenAverage is the average length of the words in the input array.

 public class Solution {
     public int wordsTyping(String[] sentence, int rows, int cols) {
         int[] nextInt = new int[sentence.length];
         int[] times = new int[sentence.length];
         for (int i=0; i<sentence.length; i++) {
             int cur = i; //try to insert string with index cur in sentence to current row
             int col = 0; //current col
             int time = 0;
             while (col + sentence[cur].length() - 1 < cols) {
                 col = col + sentence[cur++].length() + 1;
                 if (cur == sentence.length) {
                     cur = 0;
                     time++;
                 }
             }
             nextInt[i] = cur;
             times[i] = time;
         }

         int res = 0;
         int cur = 0;
         for (int i=0; i<rows; i++) {
             res += times[cur];
             cur = nextInt[cur];
         }
         return res;
     }
 }