按给定的长度格式，格式化存储给定的字符串

本题源自LeetCode https://www.nowcoder.com/practice/e03feb44880d4254b19fbdf9d124cfe2?tpId=46&tqId=29110&rp=4&ru=/ta/leetcode&qru=/ta/leetcode/question-ranking

-------------------------------------------------------

思路：

理解题意：首先要做的就是确定每一行能放下的单词数，这个不难， 就是比较n个单词的长度和加上n -1个空格的长度跟给定的长度L来比较即可。 找到了一行能放下的单词个数，然后计算出这一行存在的空格的个数， 是用给定的长度L减去这一行所有单词的长度和。得到了空格的个数之后， 就要在每个单词后面插入这些空格，这里有两种情况， 比如某一行有两个单词"to"和 "a"，给定长度L为6，如果这行不是最后一行，那么应该输出"to a"， 如果是最后一行，则应该输出 "to a"， 所以这里需要分情况讨论，最后一行的处理方法和其他行之间略有不同。 最后一个难点就是，如果一行有三个单词，这时候中间有两个空，如果空格数不是2的倍数， 那么左边的空间里要比右边的空间里多加入一个空格，那么我们只需要用总的空格数除以空间个数， 能除尽最好，说明能平均分配，除不尽的话就多加个空格放在左边的空间里

代码：

 vector<string> fullJustify(vector<string> &words, int L) {
        vector<string> result;
        int len=words.size();
        if(len==0)
            return result;
        int i=0;
        while(i<len){
            int j=i;
            int rowLen=0;
            while(j<len&&rowLen+words[j].size()+j-i<=L){  //确定每一行单词的个数
                rowLen+=words[j++].size();
            }
            int space=L-rowLen;  //确定每一行空格的个数
            string rowStr;
            for(int k=i;k<j;k++){
                rowStr+=words[k];   //将这行单词依次链接，后面加空格数
                if(space>0){  
                    int everySpace=0;
					if(j==words.size()){    //最后一行
                        if(j-k==1)          //最后一个单词，就把所有空格都插入
                        	everySpace=space;
                        else
                            everySpace=1;   //否则单词之间空格为 1
                    }else{                         
                        if(j-k-1>0){                   //不是最后一行，且单词数量大于1。则空格数平均分配。
                            if(space%(j-k-1)==0){
                                everySpace=space/(j-k-1);
                            }else{
                                everySpace=space/(j-k-1)+1;
                            }
                        }else{
                            everySpace=space;
                        }
                    }
                    rowStr.append(everySpace,' ');
                    space-=everySpace;
                }
                
            }
            result.push_back(rowStr);
            i=j;
        }
        return result;
    }

代码2：

vector<string> fullJustify(vector<string> &words, int L) {
        vector<string> res, tmp;
        int currLen = 0, endIndex = 0;
        for (int i = 0; i < words.size(); ++i) {
            int le = words[i].size();
            int ri = L - currLen;   //当前行剩余长度。
            if (le <= ri) {
                tmp.push_back(words[i]);
                currLen += words[i].size() + 1; 
            }
            else {
                int spaceNum = L - (currLen - 1);    //多减去一个空格字符 
                int wordsNum = tmp.size();
                string line;
                if (wordsNum == 1) {
                    line += tmp[0];
                    line += string(spaceNum, ' ');
                }
                else {
                    int minGap = spaceNum / (wordsNum - 1), rema = spaceNum - minGap*(wordsNum - 1);
                    for (int j = 0; j < tmp.size(); ++j) {
                        line += tmp[j];
                        if (j != tmp.size() - 1) {
                            int gap = j < rema ? (minGap + 1) : minGap;
                            for (int k = 0; k < gap + 1; ++k)
                                line.push_back(' ');
                        }
                    }
                }
                res.push_back(line);
                currLen = 0;
                tmp.clear();
                endIndex = i;
                --i;
            }
        }
        string lastLine;
        for (int i = endIndex; i < words.size(); ++i)
            lastLine += (words[i] + ' ');
        lastLine.pop_back();
        while (lastLine.size() < L)
            lastLine.push_back(' ');
        res.push_back(lastLine);
        return res;
    }