Java划分数组，去重

要求

1. 长度为n的数组遇到相同的数字就切一刀，直到数组被划分为k段 （如果k = 1，意味着不需要切）
2. 执行 unique 操作
3. 然后计算元素个数

unique 操作是指将相邻且相同的元素合成一个元素，再按照原序列的相对顺序进行排列之后得到的序列。例如，[1,1,1,2,2,3,3,1] 进行 unique 操作之后的序列为 [1,2,3,1]；[1,2,3,3,2,1] 进行 unique 操作之后的序列为 [1,2,3,2,1]；[1,1,1,1,1] 进行 unique 操作之后得到的序列为 [1]。

如：长度为8的数组分为3段，
划分前“1 1 1 2 2 3 3 1”，划分后“[1], [1], [1 2 2 3 3 1]”，然后执行 unique 操作，变成“[1], [1], [1 2 3 1]”，计算最后的结果为 1+1+4 = 6

测试用例（AI生成）：

1. 最简单的情况，n=k=1，序列S中只有一个元素。例如：

输入：
1 1
1
输出：
1

2. 序列S中所有元素都相同，k=1。例如：

输入：
5 1
2 2 2 2 2
输出：
1

3. 序列S中所有元素都相同，k>1。例如：

输入：
5 3
2 2 2 2 2
输出：
3

4. 序列S中所有元素都不同，k=1。例如：

输入：
5 1
1 2 3 4 5
输出：
5

5. 序列S中所有元素都不同，k>1。例如：

输入：
5 3
1 2 3 4 5
输出：
5

6. 序列S中有重复的元素，k>1。例如：

输入：
8 3
1 1 1 2 2 3 3 1
输出：
6

7. 序列S中有重复的元素，k=1。例如：

输入：
8 1
1 1 1 2 2 3 3 1
输出：
4

代码

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Objects;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 处理输入
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 数组长度
        int k = sc.nextInt(); // 划分为k段
        int[] s = new int[n]; // 序列S
        for (int i = 0; i < n; i++) {
            s[i] = sc.nextInt();
        }
        sc.close();
        // 数组划分
        ArrayList<LinkedList<Integer>> arrayList = getArrayList(s, k);
        // printArrayList(arrayList);
        int ans = unique(arrayList);
        // printArrayList(arrayList);
        System.out.println(ans);


    }

    private static int unique(ArrayList<LinkedList<Integer>> arrayList) {
        int ans = 0;
        int i = 0;
        for (LinkedList<Integer> list : arrayList) {
            while(i < list.size() - 1){
                if (Objects.equals(list.get(i), list.get(i + 1))) {
                    list.remove(i);
                    continue;
                }
                i++;
            }
            ans += list.size();
        }
        return ans;
    }

    private static ArrayList<LinkedList<Integer>> getArrayList(int[] s, int k) {
        ArrayList<LinkedList<Integer>> arrayList = new ArrayList<>();
        // 遇到连续相同的就切一刀，一共切 k-1 刀
        // 1 1 1 2 2 3 3 1
        // [1], [1], [1 2 2 3 3 1]
        LinkedList<Integer> linkedList = new LinkedList<>();
        for (int i = 0; i < s.length - 1; i++) {
            linkedList.add(s[i]);
            if (s[i] == s[i + 1] && k != 1) {
                // 在这里不能直接用linkedlist，因为存储的是引用，所以这个改变了其他的也会改变
                arrayList.add(new LinkedList<>(linkedList)); // 创建副本并添加到arrayList
                linkedList.clear(); // 清空linkedList
                k--;
            }
        }
        linkedList.add(s[s.length - 1]);
        arrayList.add(linkedList);
        return arrayList;
    }

    private static void printArrayList(ArrayList<LinkedList<Integer>> arrayList) {
        for (LinkedList<Integer> list : arrayList) {
            for (Integer i : list) {
                System.out.print(i);
            }
            System.out.println();
        }
    }
}