leetcode 68. 文本左右对齐

题目链接：leetcode 68

1.题目

给定一个单词数组 words 和一个长度 maxWidth ，重新排版单词，使其成为每行恰好有 maxWidth 个字符，且左右两端对齐的文本。

你应该使用 “贪心算法” 来放置给定的单词；也就是说，尽可能多地往每行中放置单词。必要时可用空格 ’ ’ 填充，使得每行恰好有 maxWidth 个字符。

要求尽可能均匀分配单词间的空格数量。如果某一行单词间的空格不能均匀分配，则左侧放置的空格数要多于右侧的空格数。

文本的最后一行应为左对齐，且单词之间不插入额外的空格。

注意:
单词是指由非空格字符组成的字符序列。
每个单词的长度大于 0，小于等于 maxWidth。
输入单词数组 words 至少包含一个单词。

2.示例

1）示例 1:
输入: words = [“This”, “is”, “an”, “example”, “of”, “text”, “justification.”], maxWidth = 16
输出:
[
“This is an”,
“example of text”,
"justification. "
]

2）示例 2:
输入:words = [“What”,“must”,“be”,“acknowledgment”,“shall”,“be”], maxWidth = 16
输出:
[
“What must be”,
"acknowledgment ",
"shall be "
]
解释: 注意最后一行的格式应为 "shall be " 而不是 “shall be”,
因为最后一行应为左对齐，而不是左右两端对齐。
第二行同样为左对齐，这是因为这行只包含一个单词。

3）示例 3:
输入:words = [“Science”,“is”,“what”,“we”,“understand”,“well”,“enough”,“to”,“explain”,“to”,“a”,“computer.”,“Art”,“is”,“everything”,“else”,“we”,“do”]，maxWidth = 20
输出:
[
“Science is what we”,
“understand well”,
“enough to explain to”,
“a computer. Art is”,
“everything else we”,
"do "
]

3.分析

如何解决这个问题，我们主要要解决两部分子问题
问题1：每一行放哪几个单词
问题2：一行的单词该如何放置
为解决问题1，我们使用sum_length_words表示目前已经考虑要放的单词的长度总和，num_words表示要放的单词的个数，那么下一个单词不能放置的边界条件是sum_length_words+num_words(因为每2个单词之间至少需要1个空格)+当前单词长度>maxWidth
为解决问题2，我们考虑所有空格个数即为maxWidth-sum_length_words，若把连续的空格当为1段，那么空格段个数即为num_words-1，考虑把n个空格分给m段，当n%m=0时，每段空格的个数为n/m，当n%m!=0时，我们把最后1个空格段拥有的空格数设为n/m，再把(n-n/m)个空格分给(m-1)个空格段知道能平均分

4.代码

class Solution {
public:
    vector<int> get_kg(int sum_length_kg,int num_kg){
        int avg_kg=sum_length_kg/num_kg;
        vector<int> ans;
        for(int i=0;i<num_kg;i++)
            ans.push_back(0);
        if(sum_length_kg%num_kg==0){
            for(int i=0;i<num_kg;i++)
                ans[i]=avg_kg;
            return ans;
        }
        while(sum_length_kg%num_kg!=0){
            ans[num_kg-1]=sum_length_kg/num_kg;
            sum_length_kg-= ans[num_kg-1];
            num_kg--;
            if(sum_length_kg%num_kg==0){
                for(int i=0;i<num_kg;i++)
                    ans[i]=sum_length_kg/num_kg;
                return ans;
            }
        }
        ans[0]=sum_length_kg;
        return ans;
    }
    vector<string> fullJustify(vector<string>& words, int maxWidth) {
        vector<string> ans;
        int n=words.size();
        int sum_length=0,cnt_words=0;
        for(int i=0;i<n;i++){
            if(sum_length+cnt_words+words[i].size()<=maxWidth){
                if(i==n-1){
                    string ans_test="";sum_length=0;
                    for(int j=i-cnt_words;j<i;j++){
                        ans_test+=words[j]+' ';
                        sum_length+=words[j].size()+1;
                    }
                    ans_test+=words[i]; sum_length+=words[i].size();  
                    for(int j=0;j<maxWidth-sum_length;j++)
                        ans_test+=' ';
                    ans.push_back(ans_test);
                    return ans;
                }
                sum_length+=words[i].size();
                cnt_words++;
                continue;
            }
            string ans_test="";
            int cnt_kg=0;
            if(cnt_words==1) cnt_kg=1;
            else cnt_kg=cnt_words-1;
            vector<int> num_kg_list=get_kg(maxWidth-sum_length,cnt_kg);
            for(int j=i-cnt_words;j<i;j++){
                ans_test+=words[j];
                if(j-(i-cnt_words)<num_kg_list.size()){
                    int num_kg=num_kg_list[j-(i-cnt_words)];
                    for(int k=0;k<num_kg;k++)
                        ans_test+=' ';
                }
            }
            ans.push_back(ans_test);
            cnt_words=1;sum_length=words[i].size();
            if(i==n-1){
                ans_test=words[i];
                for(int j=0;j<maxWidth-words[i].size();j++)
                    ans_test+=' ';
                ans.push_back(ans_test);
                return ans;
            }
        }
        return ans;
    }
};