Java 两个不同数组的最大算术序列

给定两个整数数组a和b，尝试通过将b中的整数添加到a中来创建算术序列。如果不存在算术序列，则返回a或-1的最大长度，例如a=[2,4,8]，b=[1,6,10,12]->a=[2,4,6,8,10,12]->Return 6

我尝试创建一个新的数组，合并a和b，并计算最长的子序列，但计数可以从a中删除不应该接触的元素

static int maxSeq(int[] arr1, int[] arr2){
        if(arr1.length ==0)return 0;
        int n =arr1.length, m = arr2.length;
        int[] arr = new int[n+m];
        System.arraycopy(arr1,0,arr,0,n);
        System.arraycopy(arr2,0,arr,n,m);
        Arrays.sort(arr);
        int result =0;
        Map<Integer,Integer>[]d = new HashMap[n+m];
        for(int i =0; i < arr.length;i++){
            d[i] = new HashMap<Integer, Integer>();
        }
        for(int i =1; i < arr.length; ++i){
            for(int j = 0; j<i;++j ){
                int diff = arr[i]-arr[j];

                int len =2;

                if(d[j].containsKey(diff)){
                    len = d[j].get(diff) +1;
                }



                d[i].put(diff,len);

                result = Math.max(result,d[i].get(diff));


            }
        }
        return result;
    }

static int maxSeq（int[]arr1，int[]arr2）{
如果（arr1.length==0）返回0；
int n=arr1.length，m=arr2.length；
int[]arr=新int[n+m]；
数组复制（arr1,0，arr，0，n）；
系统阵列复制（arr2,0，arr，n，m）；
数组。排序（arr）；
int结果=0；
Map[]d=新HashMap[n+m]；
对于（int i=0；i返回6
int[]a={5,7,13,14}，b={9,11,15}；返回-1而不是6
我认为您应该尝试修复代码

if（d[j].containsKey（diff））{len=d[j].get（diff）+1；}

在这里，您要查找索引j的映射中的差异，并且应该只有一个键值对映射，而不是映射数组。
这里的关键是用数组B中的数字填充数组a，使a成为算术序列

解决方案：


首先找到A中2个结果数之间的最小间隙
根据给定的“间隙”，尝试查看是否可以通过在2个数组中循环来构建算术序列，并找出B中的数字是否可以填充数组A，从而使A使用step=“间隙”进行算术运算。如果成功，则计算长度
如果可以找到，试着通过将原始“gap”的所有除数循环为新的“gap”，看看更小的gap是否可以构建更长的算术序列，然后再次测试。（示例：A=[1,5]，B=[3,7,9]=>上一步我们可以构建算术序列[1,5,9]，但最终答案应该是[1,3,5,7,9]
我想与大家分享我的解决方案（可能没有经过优化，我也没有编写过很多测试，但它对您的两个示例测试有效）：

想法：

注意算术序列的共同区别
d
的上限是
min（a[i]-a[i-1]）
，否则我们将无法访问
a
中的所有元素
我们迭代公共差
d
来检查每个潜在列表的长度，并找到最大长度
完整的Python代码：

（假设
a和b都已排序）

def max_arithmetic_length(a, b):

    min_diff = float('inf')  # common difference d is upper bounded by min_diff

    for i in range(1, len(a)):
        min_diff = min(min_diff, a[i] - a[i-1])

    d_a = {x : True for x in a}
    d_b = {x : True for x in b}

    max_cnt = 0
    for d in range(1, min_diff + 1):

        skip_current_d = False  # a switch to skip outer loop
        for x in a:
            if (x - a[0]) % d != 0:  #  must exist: a[i] - a[0] = kd
                skip_current_d = True
                break

        if skip_current_d:
            continue

        cur = a[0]
        cnt = 0
        visited = {}
        while cur in d_a or cur in d_b:
            cnt += 1
            visited[cur] = True
            cur += d

        if a[-1] not in visited:  # if the last element in a is visited, then every element in a is visited
            continue

        # check those smaller than a[0] (may only exist in b)
        cur = a[0] - d
        while cur in b:
            cnt += 1
            cur -= d

        max_cnt = max(cnt, max_cnt)

    return max_cnt if max_cnt  else -1

a = [2, 4, 8]
b = [1, 6, 10, 12]
print(max_arithmetic_length(a,b))  # return  6

a = [5,7,13,14]
b = [9,11,15]
print(max_arithmetic_length(a,b))  # return -1