1. //小写字符 的 数值 是它在字母表中的位置（从 1 开始），因此 a 的数值为 1 ，b 的数值为 2 ，c 的数值为 3 ，以此类推。 
    2. //
    3. // 字符串由若干小写字符组成，字符串的数值 为各字符的数值之和。例如，字符串 "abe" 的数值等于 1 + 2 + 5 = 8 。 
    4. //
    5. // 给你两个整数 n 和 k 。返回 长度 等于 n 且 数值 等于 k 的 字典序最小 的字符串。 
    6. //
    7. // 注意，如果字符串 x 在字典排序中位于 y 之前，就认为 x 字典序比 y 小，有以下两种情况： 
    8. //
    9. // 
    10. // x 是 y 的一个前缀； 
    11. // 如果 i 是 x[i] != y[i] 的第一个位置，且 x[i] 在字母表中的位置比 y[i] 靠前。 
    12. // 
    13. //
    14. // 
    15. //
    16. // 示例 1： 
    17. //
    18. // 
    19. //输入：n = 3, k = 27
    20. //输出："aay"
    21. //解释：字符串的数值为 1 + 1 + 25 = 27，它是数值满足要求且长度等于 3 字典序最小的字符串。 
    22. //
    23. // 示例 2： 
    24. //
    25. // 
    26. //输入：n = 5, k = 73
    27. //输出："aaszz"
    28. // 
    29. //
    30. // 
    31. //
    32. // 提示： 
    33. //
    34. // 
    35. // 1 <= n <= 105 
    36. // n <= k <= 26 * n 
    37. // 
    38. // Related Topics 贪心算法 
    39. // 👍 18 👎 0

    拿到这题之后，我的想法是先从’a’开始放，放到最后再把多数字依次向前排
    因为要求固定长度，且总和是k，要求字典序最小。
    那么’a’的字典序是最小的，所以可以先安排’a’

    2. class Solution {
    3.     public String getSmallestString(int n, int k) {
    4.         char[] res = new char[n];
    5.         for (int i = 0; i < n; i++) {
    6.             // 先安排a
    7.             res[i] = 'a';
    8.         }
    9.         // 安排了n个a，a的值是1，所以要减去n
    10.         k -= n;
    11.         // 目前安排到哪个位置了，要求字典序最低，就从最后一个安排
    12.         int index = n - 1;
    13.         while (k > 0) {
    14.             // 先紧着最后一个安排，能放多少就放多少
    15.             if (k >= 25) {
    16.                 k -= 25;
    17.                 res[index] = 'z';
    18.                 index --;
    19.             }else {
    20.                 // 已经不能放z了，那就有多少放多少
    21.                 res[index] = (char) ('a' + k);
    22.                 k = 0;
    23.                 index --;
    24.             }
    25.         }
    26.         return new String(res);
    27.     }
    28. }