leetcode | Text Justification

Given an array of words and a length L, format the text such that each line has exactly L characters and is fully (left and right) justified.

You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces ' ' when necessary so that each line has exactly L characters.

Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line do not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.

For the last line of text, it should be left justified and no extra space is inserted between words.

For example,
words: ["This", "is", "an", "example", "of", "text", "justification."]
L: 16.

Return the formatted lines as:
[
"This is an",
"example of text",
"justification. "
]
Note: Each word is guaranteed not to exceed L in length.

A line other than the last line might contain only one word. What should you do in this case?
In this case, that line should be left-justified.

这道题正确地处理各种计数，再分情况处理就可以了。

主要分三种情况:

1. 只有一个单词。左对齐，右补空白；

2. 最后一行，单词之间只有一个空白；

3. 其他行，多个单词，那么就要平均空白；如果不能平均，那么就取余数，前几个就要多一个空白，尽量平均；(Line 31-35)

在计算是否能够容纳单词的时候，要算上空白。所以用了一个length计算每个单词之间至少一个空白的总长度，再用sum计算只有单词的总长度，方便计算空格数。（Line 17-18)

class Solution {
public:
    vector<string> fullJustify(vector<string> &words, int L) {
        vector<string> ret;
        int n = words.size();
        if (n == 0) return ret;
        if (L <= 0) {
            ret.push_back("");
            return ret;
        }
        
        int s = 0, e = s, count, pad, sum, length, left;
        while (true) {
            if (s >= n) break;
            sum = length = words[s].length();
            for (e = s + 1; e < n && (length + words[e].length() + 1) <= L; ++e) {
                sum += words[e].length();
                length += 1 + words[e].length();
            }
            count = e - s;
            string tmp(words[s]);
            if (count == 1) {
                tmp.append(L - sum, ' ');
            } else if (e == n) {                
                for (int i = s + 1; i < e; ++i) {
                    tmp += " " + words[i];
                }
                tmp.append(L - sum - count + 1, ' ');
            } else {
                pad = L - sum;
                left = pad % (count - 1);
                pad = pad / (count - 1);
                for (int i = s + 1; i < e; ++i) {
                    tmp.append(pad, ' ');
                    if (left-- > 0) tmp.append(1, ' ');
                    tmp += words[i];
                }
            }
            ret.push_back(tmp);
            s = e;
        }
        
        return ret;
    }
};

 第三次写，一开始就把只含一个数的情况单独考虑，然后再把中间行和最后一行分开考虑，这样写清晰许多。

class Solution {
public:
    vector<string> fullJustify(vector<string> &words, int L) {
        vector<string> ans;
        int n = words.size();
        for (int start = 0; start < n; ) {
            if (words[start].length() == L || start == n - 1 
                || words[start].length() + words[start + 1].length() + 1 > L) { // only one element
                if (words[start].length() < L) words[start].append(L - words[start].length(), ' ');
                ans.push_back(words[start++]);
            } else { // more than one element
                int end = start, len = -1;
                for (; end < n && len + words[end].length() + 1 <= L; len += words[end].length() + 1, ++end);
                stringstream ss;
                if (end == n) { // last line
                    for (int i = start; i < end - 1; ++i) {
                        ss << words[i] << " ";
                    }
                    if (L - len > 0) words[end - 1].append(L - len, ' ');
                    ss << words[end - 1];
                } else { // middle lines
                    int space = (L - len) / (end - start - 1), extra = (L - len) % (end - start - 1);
                    for (int i = start; i < end - 1; ++i) {
                        string spaces = "";
                        spaces.append(space + 1, ' ');
                        if (extra-- > 0) spaces.append(1, ' ');
                        ss << words[i] << spaces;
                    }
                    ss << words[end - 1];
                }
                ans.push_back(ss.str());
                start = end;
            }
        }
        
        return ans;
    }
};