从0开始的秋招刷题路，记录下所刷每道题的题解，帮助自己回顾总结

68. 文本左右对齐

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

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

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

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

注意:

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

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

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

示例 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 "
]

提示:
1 <= words.length <= 300
1 <= words[i].length <= 20
words[i] 由小写英文字母和符号组成
1 <= maxWidth <= 100
words[i].length <= maxWidth

一个句子，和一个长度表示一行最长的长度，然后对齐文本，有下边几个规则。

1. 同一个单词只能出现在一行中，不能拆分
2. 一行如果只能放下一个单词，该单词放在最左边，然后空格补齐，例如 “acknowledgement#####”，这里只是我为了直观，# 表示空格，题目并没有要求。
3. 一行如果有多个单词，最左边和最右边不能有空格，每个单词间隙尽量平均，如果无法平均，把剩余的空隙从左边开始分配。例如，“enough###to###explain##to”，3 个间隙，每个 2 个空格的话，剩下 2 个空格，从左边依次添加一个空格。
4. 最后一行执行左对齐，单词间一个空格，末尾用空格补齐。

解法一
这道题关键就是理解题目，然后就是一些细节的把控了，我主要是下边的想法。

一行一行计算该行可以放多少个单词，然后计算单词间的空隙是多少，然后把它添加到结果中。

public List<String> fullJustify(String[] words, int maxWidth) {List<String> ans = new ArrayList<>();//当前行单词已经占用的长度int currentLen = 0;//保存当前行的单词List<String> row = new ArrayList<>();//遍历每个单词for (int i = 0; i < words.length;) {//判断加入该单词是否超过最长长度//分了两种情况，一种情况是加入第一个单词，不需要多加 1//已经有单词的话，再加入单词，需要多加个空格，所以多加了 1if (currentLen == 0 && currentLen + words[i].length() <= maxWidth|| currentLen > 0 && currentLen + 1 + words[i].length() <= maxWidth) {row.add(words[i]);if (currentLen == 0) {currentLen = currentLen + words[i].length();} else {currentLen = currentLen + 1 + words[i].length();}i++;//超过的最长长度，对 row 里边的单词进行处理} else {//计算有多少剩余，也就是总共的空格数，因为之前计算 currentLen 多算了一个空格，这里加回来int sub = maxWidth - currentLen + row.size() - 1;//如果只有一个单词，那么就直接单词加空格就可以if (row.size() == 1) {String blank = getStringBlank(sub);ans.add(row.get(0) + blank);} else {//用来保存当前行的结果StringBuilder temp = new StringBuilder();//将第一个单词加进来temp.append(row.get(0));//计算平均空格数int averageBlank = sub / (row.size() - 1);//如果除不尽，计算剩余空格数int missing = sub - averageBlank * (row.size() - 1);//前 missing 的空格数比平均空格数多 1String blank = getStringBlank(averageBlank + 1);int k = 1;for (int j = 0; j < missing; j++) {temp.append(blank + row.get(k));k++;}//剩下的空格数就是求得的平均空格数blank = getStringBlank(averageBlank);for (; k < row.size(); k++) {temp.append(blank + row.get(k));}//将当前结果加入 ans.add(temp.toString());}//清空以及置零row = new ArrayList<>();currentLen = 0;}}//单独考虑最后一行，左对齐StringBuilder temp = new StringBuilder();temp.append(row.get(0));for (int i = 1; i < row.size(); i++) {temp.append(" " + row.get(i));}//剩余部分用空格补齐temp.append(getStringBlank(maxWidth - currentLen));//最后一行加入到结果中ans.add(temp.toString());return ans;
}
//得到 n 个空白
private String getStringBlank(int n) {StringBuilder str = new StringBuilder();for (int i = 0; i < n; i++) {str.append(" ");}return str.toString();
}

但是这个算法，在 leetcode 跑，速度只打败了 30% 多的人，1 ms。然后在 discuss 里转了一圈寻求原因，发现大家思路都是这样子，然后找了一个人的跑了下

public List<String> fullJustify(String[] words, int maxWidth) {int left = 0; List<String> result = new ArrayList<>();while (left < words.length) {int right = findRight(left, words, maxWidth);result.add(justify(left, right, words, maxWidth));left = right + 1;}return result;
}//找到当前行最右边的单词下标
private int findRight(int left, String[] words, int maxWidth) {int right = left;int sum = words[right++].length();while (right < words.length && (sum + 1 + words[right].length()) <= maxWidth)sum += 1 + words[right++].length();return right - 1;
}//根据不同的情况添加不同的空格
private String justify(int left, int right, String[] words, int maxWidth) {if (right - left == 0) return padResult(words[left], maxWidth);boolean isLastLine = right == words.length - 1;int numSpaces = right - left;int totalSpace = maxWidth - wordsLength(left, right, words);String space = isLastLine ? " " : blank(totalSpace / numSpaces);int remainder = isLastLine ? 0 : totalSpace % numSpaces;StringBuilder result = new StringBuilder();for (int i = left; i <= right; i++)result.append(words[i]).append(space).append(remainder-- > 0 ? " " : "");return padResult(result.toString().trim(), maxWidth);
}//当前单词的长度
private int wordsLength(int left, int right, String[] words) {int wordsLength = 0;for (int i = left; i <= right; i++) wordsLength += words[i].length();return wordsLength;
}private String padResult(String result, int maxWidth) {return result + blank(maxWidth - result.length());
}private String blank(int length) {return new String(new char[length]).replace('\0', ' ');
}

看了下，发现思想和自己也是一样的。但是这个速度却打败了 100% ，0 ms。考虑了下，差别应该在我的算法里使用了一个叫做 row 的 list 用来保存当前行的单词，用了很多 row.get ( index )，而上边的算法只记录了 left 和 right 下标，取单词直接用的 words 数组。然后尝试着在我之前的算法上改了一下，去掉 row，用两个变量 start 和 end 保存当前行的单词范围。主要是 ( end - start ) 代替了之前的 row.size ( )， words [ start + k ] 代替了之前的 row.get ( k )。

public List<String> fullJustify2(String[] words, int maxWidth) {List<String> ans = new ArrayList<>();int currentLen = 0;int start = 0;int end = 0;for (int i = 0; i < words.length;) {//判断加入该单词是否超过最长长度//分了两种情况，一种情况是加入第一个单词，不需要多加 1//已经有单词的话，再加入单词，需要多加个空格，所以多加了 1if (currentLen == 0 && currentLen + words[i].length() <= maxWidth|| currentLen > 0 && currentLen + 1 + words[i].length() <= maxWidth) {end++;if (currentLen == 0) {currentLen = currentLen + words[i].length();} else {currentLen = currentLen + 1 + words[i].length();}i++;} else {int sub = maxWidth - currentLen + (end - start) - 1;if (end - start == 1) {String blank = getStringBlank(sub);ans.add(words[start] + blank);} else {StringBuilder temp = new StringBuilder();temp.append(words[start]);int averageBlank = sub / ((end - start) - 1);//如果除不尽，计算剩余空格数int missing = sub - averageBlank * ((end - start) - 1);String blank = getStringBlank(averageBlank + 1);int k = 1;for (int j = 0; j < missing; j++) {temp.append(blank + words[start+k]);k++;}blank = getStringBlank(averageBlank);for (; k <(end - start); k++) {temp.append(blank + words[start+k]);}ans.add(temp.toString());}start = end;currentLen = 0;}}StringBuilder temp = new StringBuilder();temp.append(words[start]);for (int i = 1; i < (end - start); i++) {temp.append(" " + words[start+i]);}temp.append(getStringBlank(maxWidth - currentLen));ans.add(temp.toString());return ans;
}
//得到 n 个空白
private String getStringBlank(int n) {StringBuilder str = new StringBuilder();for (int i = 0; i < n; i++) {str.append(" ");}return str.toString();
}

果然，速度也到了打败 100%，0 ms。

总
充分说明 list 的读取还是没有数组的直接读取快呀，还有就是要向上边的作者学习，多封装几个函数，思路会更加清晰，代码也会简明。