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;
    }
}