【美团一题】中位数

最新推荐文章于 2025-03-23 20:34:35 发布

slow is fast.

最新推荐文章于 2025-03-23 20:34:35 发布

阅读量560

点赞数

CC 4.0 BY-SA版权

分类专栏： # 大厂高频题文章标签： java uml 开发语言

本文链接：https://blog.youkuaiyun.com/wwj17647590781/article/details/123762219

大厂高频题专栏收录该内容

26 篇文章

订阅专栏

本文介绍了一种使用双指针技术解决特定问题的方法，并通过一个实例展示了如何利用回溯算法结合优先队列来寻找所有可能的子集并计算中位数之和。文章通过具体的Java代码实现了两种算法，并探讨了它们在处理数组和集合问题上的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在这里插入图片描述
双指针：

public class meituanText {
    public static void main(String[] args) {
//        int[] arr={1,2,3};
//        int n = arr.length;
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[] arr=new int[n];
        for(int i=0;i<n;i++){
            arr[i]=sc.nextInt();
        }
        int sum = 0;
        int result = 0;
        List<List<Integer>> list=new ArrayList<>();
        List<Integer> temp=new ArrayList<>();
        for(int start=0;start<n;start++){
            for (int right = start; right < arr.length; right += 2) {
                if (right >= arr.length) {
                    break;
                }
                int[] nums = new int[right - start + 1];
                for (int i = start; i <= right; i++) {
                    nums[i-start] = arr[i];
                }
                Arrays.sort(nums);
                result += find(nums);
            }
        }
        System.out.println(result);
    }
    private static int find(int[] nums) {
        if (nums.length == 1) {
            return nums[0];
        }
        return nums[nums.length / 2];
    }
}

回溯+优先队列固定顺序

public class Test {
    static List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
    static LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
    static Queue<Integer> queue = new PriorityQueue<>((x,y)->(y-x));//大顶堆
    public static void main(String[] args) {
        int res = 0;
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr=new int[n];
        for(int i=0;i<n;i++){
            arr[i]=sc.nextInt();
        }
        subsets(arr);
        for (int i = 0; i < result.size(); i++) {
            if ((result.get(i).size()&1) == 0) {
                result.remove(i);
            }

        }
        System.out.println(result);
        for(int i = 0 ; i<result.size() ; i++){
            int len = result.get(i).size();
            int[] a = new int[len];
            for(int j=0 ; j<len; j++) a[j] = result.get(i).get(j) ;
            Arrays.sort(a);
            res += len==0 ? a[0] : a[a.length/2];
        }
        System.out.println(res);
    }
    public static List<List<Integer>> subsets(int[] nums) {
        if (nums.length == 0){
            result.add(new ArrayList<>());
            return result;
        }
        subsetsHelper(nums, 0);
        return result;
    }
    private static void subsetsHelper(int[] nums, int startIndex){
        result.add(new ArrayList<>(path));
        if (startIndex >= nums.length){ 
            return;
        }
        for (int i = startIndex; i < nums.length; i++){
            if(!queue.isEmpty() && (queue.peek()+1)!=i)
                continue;
            queue.add(i);
            path.add(nums[i]);
            subsetsHelper(nums, i + 1);
            path.removeLast();
            queue.remove(i);
        }
    }
}