java - 执行k次操作后如何最小化最终数组中元素的总和

Question

这个问题在我的面试编码中被问到，有 12 个测试用例，我只能通过其中的 8 个。 minSum(List values, int k) 方法需要完成。
示例:nums = [10,20,7] 和 k=4 这个数组的答案是 5+5+4=14。每个操作包括从数组中删除元素，将其除以 2 并将该结果的上限插入回数组中。

我的解决方案是这样的:

if (num != null) {
        Collections.sort(num);

        while (k != 0) {
            for (int i = num.size() - 1; i >= 0 && k != 0; i--) {

                int number = (int) Math.ceil((double) num.get(i) / 2);

                num.set(i, number);
                k--;
            }
        }
    }
    return getMinSumOfArray(num);

测试用例: nums[2], k= 1 那么答案是 1
如果 nums[2,3], k = 1 那么答案是 4

这些是简单的测试用例，但是您需要执行 100000 个随机数数组和 1000000 个操作步骤。

我失败的测试用例之一:

[1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 12, 12, 12, 12, 13, 14, 16, 17, 18, 19, 20, 20, 21, 22, 22, 22, 22, 22, 23, 23, 23, 23, 25, 25, 25, 26, 26, 27, 27, 27, 27, 28, 28, 29, 29, 30, 30, 30, 31, 31, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 36, 37, 37, 37, 38, 38, 38, 39, 39, 40, 42, 43, 43, 44, 44, 44, 45, 45, 45, 45, 45, 46, 46, 47, 47, 48, 48, 49, 50, 50, 52, 53, 54, 55, 56, 57, 58, 58, 59, 60, 60, 61, 62, 64, 64, 64, 64, 65, 65, 65, 66, 67, 67, 68, 69, 69, 69, 69, 70, 71, 71, 73, 73, 73, 74, 74, 74, 74, 75, 76, 77, 77, 77, 78, 78, 80, 81, 81, 81, 81, 82, 83, 83, 84, 84, 85, 85, 85, 86, 86, 86, 88, 88, 88, 89, 89, 90, 91, 92, 92, 93, 93, 93, 95, 96, 96, 96, 96, 97, 97, 97, 97, 97, 98, 98, 98, 98, 99, 100, 100, 101, 101, 101, 102, 102, 103, 103, 104, 105, 106, 106, 106, 106, 107, 107, 107, 108, 108, 108, 109, 109, 110, 111, 111, 113, 113, 114, 115, 115, 117, 117, 117, 117, 119, 119, 119, 119, 119, 120, 120, 120, 120, 121, 121, 121, 121, 122, 122, 122, 123, 123, 123, 125, 125, 126, 128, 129, 130, 130, 130, 130, 131, 131, 133, 134, 134, 134, 135, 135, 135, 135, 135, 136, 136, 137, 138, 139, 139, 140, 140, 143, 143, 144, 145, 145, 146, 146, 146, 147, 147, 148, 148, 148, 149, 149, 149, 150, 150, 151, 151, 151, 152, 152, 152, 152, 152, 153, 153, 154, 154, 154, 154, 155, 157, 157, 158, 159, 159, 159, 159, 160, 161, 162, 162, 163, 164, 164, 164, 165, 165, 167, 167, 168, 168, 169, 170, 171, 171, 171, 171, 172, 172, 172, 173, 174, 175, 175, 176, 176, 176, 177, 179, 179, 179, 179, 180, 181, 181, 181, 182, 183, 183, 184, 184, 184, 184, 186, 187, 188, 188, 189, 189, 189, 190, 190, 190, 190, 191, 192, 192, 192, 192, 192, 193, 193, 193, 194, 194, 194, 194, 196, 196, 197, 197, 197, 200, 200, 201, 201, 202, 203, 203, 205, 205, 206, 207, 207, 207, 208, 208, 208, 210, 210, 210, 210, 211, 212, 212, 212, 213, 213, 213, 214, 214, 214, 215, 216, 216, 216, 217, 218, 218, 218, 218, 220, 220, 221, 221, 222, 222, 222, 222, 222, 223, 223, 224, 224, 224, 224, 225, 225, 225, 226, 227, 228, 228, 230, 231, 232, 232, 232, 233, 235, 235, 235, 235, 236, 236, 237, 238, 238, 238, 238, 239, 240, 240, 241, 243, 244, 244, 245, 245, 245, 246, 246, 246, 246, 247, 248, 248, 249, 249, 249, 250, 250, 251, 251, 251, 252, 252, 252, 253, 254, 255, 255, 256, 256, 256, 257, 257, 257, 258, 258, 259, 259, 259, 260, 261, 261, 261, 262, 262, 262, 263, 263, 263, 264, 265, 266, 267, 267, 267, 268, 269, 269, 270, 270, 271, 271, 271, 272, 272, 273, 273, 273, 274, 275, 275, 276, 276, 277, 279, 279, 279, 281, 281, 281, 281, 282, 282, 282, 283, 284, 285, 285, 286, 286, 288, 288, 288, 288, 288, 289, 290, 290, 291, 291, 291, 292, 293, 293, 294, 295, 295, 295, 297, 297, 297, 297, 297, 298, 299, 300, 300, 301, 301, 301, 301, 303, 303, 303, 304, 304, 305, 305, 306, 306, 306, 307, 307, 307, 307, 308, 308, 309, 309, 309, 309, 310, 311, 311, 311, 312, 312, 312, 313, 313, 314, 315, 315, 315, 316, 317, 318, 318, 318, 318, 319, 321, 322, 322, 323, 323, 324, 324, 324, 325, 325, 325, 325, 325, 326, 326, 326, 326, 326, 327, 327, 327, 327, 327, 329, 329, 329, 329, 329, 329, 330, 331, 332, 332, 332, 333, 333, 333, 333, 333, 334, 334, 335, 335, 335, 335, 336, 336, 337, 338, 338, 339, 339, 340, 340, 341, 341, 342, 342, 342, 342, 343, 343, 344, 345, 345, 345, 346, 349, 350, 351, 351, 351, 351, 352, 352, 353, 353, 354, 354, 356, 356, 356, 356, 356, 357, 358, 358, 358, 359, 359, 360, 361, 361, 361, 361, 363, 363, 364, 364, 365, 365, 366, 366, 366, 366, 367, 368, 368, 369, 370, 370, 370, 371, 372, 372, 372, 372, 373, 374, 375, 375, 376, 376, 376, 376, 377, 377, 377, 377, 378, 378, 378, 379, 380, 380, 380, 381, 381, 381, 381, 382, 382, 382, 384, 384, 384, 386, 386, 387, 387, 389, 390, 390, 391, 391, 391, 392, 392, 393, 393, 394, 394, 394, 394, 394, 394, 395, 395, 395, 396, 396, 396, 396, 396, 397, 397, 398, 398, 398, 398, 399, 400, 402, 402, 403, 404, 404, 404, 405, 406, 406, 407, 407, 407, 409, 409, 410, 411, 413, 413, 413, 413, 414, 414, 415, 416, 416, 416, 417, 417, 418, 418, 418, 419, 419, 419, 419, 420, 421, 421, 421, 421, 422, 423, 423, 424, 425, 426, 426, 428, 429, 429, 429, 429, 429, 429, 429, 430, 430, 430, 431, 431, 432, 432, 432, 433, 433, 434, 436, 437, 437, 437, 438, 439, 439, 441, 441, 441, 442, 442, 443, 444, 445, 445, 445, 446, 446, 447, 447, 448, 450, 450, 450, 451, 451, 452, 452, 453, 453, 453, 454, 454, 455, 455, 456, 456, 458, 459, 459, 460, 461, 461, 462, 463, 463, 463, 464, 464, 465, 465, 467, 467, 467, 469, 469, 471, 472, 472, 473, 473, 473, 474, 474, 474, 476, 476, 476, 477, 477, 477, 478, 479, 479, 480, 480, 480, 480, 480, 481, 481, 481, 481, 481, 482, 482, 483, 484, 485, 486, 487, 488, 489, 489, 490, 491, 491, 493, 493, 493, 494, 494, 494, 495, 495, 495, 496, 496, 497, 497, 497, 498, 499, 500, 500, 500, 500]

k= 565

Answer 1

根据我的测试，这似乎非常快。

算法如下:

将最大元素初始化为 MAX_INTEGER .第一次通过这个触发
那种。

继续处理和应用测试，直到当前值更小
比最大值。

然后resort , 重置 index并重新分配一个新的 max .

继续，直到应用了所有测试

这很有效，因为所有值都会被处理，直到当前值小于最大值。那么将测试应用于较小的值是没有意义的，是时候求助了。
k = 0 or 1边境案件, entries = 0 or 1也经过测试。

    public static long minimalSum(List<Integer> data, int ktests) {
        if (data.size() == 0) {
            return 0;
        }

        int index = 0;
        int max = Integer.MAX_VALUE;
        while (ktests > 0) {
            int currentValue = data.get(index);
            if (currentValue <= max) {
                data.sort(Comparator.reverseOrder());
                index = 0;
                max = data.get(0) / 2;
                continue;
            }
            ktests--;

            int roundUp = currentValue & 1;
            currentValue /= 2;
            currentValue += roundUp;

            data.set(index, currentValue);
            if (index + 1 < data.size()) {
                index++;
            }
        }
        return data.stream().mapToLong(a->a).sum();
    }