Question

我正在努力完成非常有趣的任务并寻求建议。这种情况是从给定的对列表中找到最长的子列表。这些对中的第一个元素应按升序排列，第二个元素按降序排列。

例如，对于{{1,3},{3,1},{2,0},{4,4},{5,3},{6,2}}，答案为{{4,4},{5,3},{6,2}}

所以，我怎么看这个：通过数组并检查两对的条件，如果条件为真，则在某处保存值并增加子列表元素数。否则，检查当前子列表记录是否为空，并将最后一个元素添加到当前子列表，然后检查该子列表是否是最长的。我遇到了两个主要问题 - 重复和缺少最后一个元素。

这一刻我来到这里：

     public static void findLagrestList() {
        int arr[][] = {{1,3},{3,1},{2,0},{4,4},{5,3},{6,2}};

        ArrayList<int[]> currentSublist = new ArrayList<>();
        ArrayList<int[]> resultSublist = new ArrayList<>();

        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr[i].length-1; j++) {
                if (arr[i][j] < arr[i + 1][j] && arr[i][j + 1] > arr[i + 1][j + 1]) {
                    if(!currentSublist.contains(arr[i])){
                        currentSublist.add(arr[i]);
                    }

                } else {
                    currentSublist.add(arr[i]);//the last one
                    if(currentSublist.size()>resultSublist.size()){
                        resultSublist.clear();
                        resultSublist.addAll(currentSublist);
                        currentSublist.clear();
                    }

                    break;
                }
            }   
        }
System.out.println(resultSublist.size());
printList(resultSublist);

}

private static void printList(ArrayList<int[]> list) {

        for (int[] is : list) {
            System.out.println();
            for (int i : is) {
                System.out.print(i + " ");

            }
        }
    }

输出：

提前感谢任何线索或提示。

Answer 1

好的，首先提示一下。

对于给定x的每一对（x，y），您只对y最大的一对感兴趣。

对于给定y的每对（x，y），您只对x最小的一对感兴趣。

尝试为x和y建立相应最小值/更大值的地图，并查看从那里获得的位置（您需要两个副本列表，一个按字典顺序排序x - ＆gt; y和一个按字典顺序排序y - ＆gt; x）。

Answer 2

我为你写了这个算法它完全符合你的要求。

1）我创建一个结果ArrayList;

2）将变量sum初始化为0;

3）循环遍历每个数组值array[][];的所有值，得到其组件的总和

4）如果数组值的组件总和小于或等于sum，则将数组值插入结果数组

5）但是如果数组值的组件总和大于sum，则检查结果数组。如果为空则插入数组值。如果它不为空，则检查结果Arraylist的每个值的组件总和与soucrce数组的值的组件之和。删除任何小于源数组件的和的值，然后将此特定值插入结果arraylist。

import java.util.ArrayList;
class lists{
     public static void findLagrestList() {
            int arr[][] = {{1,3},{3,1},{2,0},{4,4},{5,3},{6,2}};

            //ArrayList<int[]> currentSublist = new ArrayList<>();
            ArrayList<int[]> resultSublist = new ArrayList<>();

            int result_arr[][]={};

            int sum =0;
            for(int i=0;i<arr.length;i++)
            {
                int [] inner_arr =arr[i];
                int valuesum =arr[i][0]+arr[i][1];
                if(valuesum>sum)
                {
                    if(resultSublist.size()>0)
                    {
                        for(int k=0;k<resultSublist.size();k++)
                        {
                            int [] cvalue = resultSublist.get(k);
                            int summ=cvalue[0]+cvalue[1];
                            if(valuesum>summ)
                            {
                               resultSublist.remove(k) ;
                            }

                        }
                        resultSublist.add(inner_arr);
                    }else{
                        resultSublist.add(inner_arr);
                        sum = valuesum;
                    }
                }
            }



System.out.println(resultSublist.size());
printList(resultSublist);

}

    private static void printList(ArrayList<int[]> list) {

        for (int[] is : list) {
            System.out.println();
            for (int i : is) {
                System.out.print(i + " ");

            }
        }
    }

    public static void main(String [] oo)
    {
         lists.findLagrestList();
    }

}

输出

最长的子列表算法

2 个答案: