Leetcode689 wrong greedy thinking

The title is to find 3 A length of k Non overlapping subarrays of , And the biggest .
Wrong thinking ：
At first, it was understood as non coincidence , As long as there is one difference, there are different subarrays . So first we use the sliding window to generate all the data with the length of k The sum of subarrays of , Choose the largest one 3 individual .
Later, it was found that there was no overlap , Want to use greed , First select the largest subinterval , Then choose the non overlapping and the largest . Knowing that this does not necessarily guarantee an optimal solution , Try to choose before 10 Large subinterval , Then select the largest non overlapping subinterval from the subinterval smaller than it .
The code is as follows

    private boolean chongDie(int b, List<Integer> a, int k) {
    
        for (int t : a) {
    
            if (Math.abs(b - t) < k) {
    
                return true;
            }
        }
        return false;
    }

    public int[] maxSumOfThreeSubarrays2(int[] nums, int k) {
    
        long cur = 0L;
        List<Pair<Long, Integer>> list = new ArrayList<>();
        for (int i = 0; i < k; i++) {
    
            cur += nums[i];
        }
        list.add(new Pair<>(cur, 0));
        for (int i = k; i < nums.length; i++) {
    
            cur -= nums[i - k];
            cur += nums[i];
            list.add(new Pair<>(cur, i - k + 1));
        }
        System.out.println(list);
        list.sort(new Comparator<Pair<Long, Integer>>() {
    
            @Override
            public int compare(Pair<Long, Integer> o1, Pair<Long, Integer> o2) {
    
                if (o1.getKey().equals(o2.getKey())) {
    
                    if (o1.getValue() < o2.getValue()) {
    
                        return -1;
                    }
                } else if (o1.getKey() < o2.getKey()) {
    
                    return 1;
                } else if (o1.getKey() > o2.getKey()) {
    
                    return -1;
                }
                return 0;
            }
        });
        System.out.println(list);
        long sum = 0L;
        int[] ans = new int[3];
        for (int st = 0; st < Math.min(10, list.size()); st++) {
    
            cur = 0L;
            List<Integer> res = new ArrayList<>();
            res.add(list.get(st).getValue());
            cur += list.get(st).getKey();
            for (int i = st + 1; i < list.size(); i++) {
    
                if (!chongDie(list.get(i).getValue(), res, k)) {
    
                    cur += list.get(i).getKey();
                    res.add(list.get(i).getValue());
                    if (res.size() == 3) {
    
                        break;
                    }
                }
            }
            if (cur > sum) {
    
                Collections.sort(res);
                for (int i = 0; i < 3; i++) {
    
                    ans[i] = res.get(i);
                }
                sum = cur;
            }
        }
        return ans;
    }

For input

[17,7,19,11,1,19,17,6,13,18,2,7,12,16,16,18,9,3,19,5]
6

My output is

[0,6,12]

The correct output is

[0,6,13]

Look at the , The length is k The subinterval of is as follows ：

[74=0, 74=1, 73=2, 67=3, 74=4, 75=5, 63=6, 58=7, 68=8, 71=9, 71=10, 78=11, 74=12, 81=13, 70=14]
[81=13, 78=11, 75=5, 74=0, 74=1, 74=4, 74=12, 73=2, 71=9, 71=10, 70=14, 68=8, 67=3, 63=6, 58=7]

My program didn't choose 13, It chose the first and longest one 12.
Because election 13, The last choice is greed , The final choice is 13、5, The optimal solution is still not guaranteed . So my program chose 13 There is no answer to the question .