在包含 M*N 混洗元素的列表中查找 N 个元素的 M 算术序列

Question

问题： M 个算术级数，每个具有 N 项（项相差 d1,d2,...dm）作为输入，其中项被打乱。程序必须按顺序打印 M 等差数列中的项，最小的开始项在前。

输入格式： 第一行包含 M 的值 第二行包含用空格分隔的术语（术语的数量将是 M*N）

边界条件： 2 = 3

输出格式： 级数中的项（每个以空格分隔）按顺序排列，具有最小起始项的级数首先出现。

输入/输出示例 1：

输入：

2
1 4 8 12 7 16

输出：

1 4 7 8 12 16

解释：

There are two progressions. Hence 6/2 = 3 terms in each progression.
So the first A.M has 1 4 7 and the second has 8 12 16
As 1 < 8, 1 4 7 is printed followed by 8 12 16

示例输入/输出 2：

输入：

3
2 6 8 10 15 22 12 11 4

输出：

2 4 6 8 15 22 10 11 12

解释：

There are three progressions. Hence 9/3 = 3 terms in each progression.
So the first A.M has 2 4 6 and the second has 8 15 22. The third has 10 11 12.

注意：我们不能将 8 10 12 作为第二级数，因为其余数字 11 15 22 不能作为算术级数。

输入/输出示例 3：

输入：

4
20 24 28 32 41 46 51 50 60 90 10 170 70 36 40 250

输出：

10 90 170 250 20 24 28 32 36 41 46 51 40 50 60 70

输入/输出示例 4：

输入：

3
180 66 100 44 120 55 60 400 200 300 33 240

输出：

33 44 55 66 60 120 180 240 100 200 300 400

我的代码（到目前为止）：

from __future__ import division
from itertools import permutations

m=int(raw_input())
values=map(int,raw_input().split())
terms=len(values)/m
permutation=list(permutations(values,terms))
lst=[]
for i in range(m):
    for perm in permutation:
        mean=sum(perm)/len(perm)
        temp=list(sorted(perm))
        if temp in lst:
            continue
        if len(perm)%2==0:
            med=(temp[int((len(temp)/2)-1)]+temp[int(len(temp)/2)])/2
            if med==mean:
                lst+=[temp]
        else:
            med=temp[int(len(temp)/2)]
            if med==mean:
                lst+=[temp]
lst=sorted(lst,key=lambda x:x[0])
print lst

我能够列出给定输入中所有可能的算术序列，但不知道如何从那里开始。

Answer 1

def explore(n, terms, seqs):

    if not terms:  # if all terms have been processed, you found a solution
        return {tuple(sum(sorted(seqs), []))}

    result = set()

    for ix, seq in enumerate(seqs):

        new_seqs = list(seqs)
        new_seqs[ix] = seq + [terms[0]]

        if len(seq) == 0:  # if you are adding to an empty sequence
            if ix == 0 or len(seqs[ix - 1]) > 0:  # be sure previous is not empty
                result.update(explore(n, terms[1:], new_seqs))
            break  # don't bother checking following seqs, they are empty

        elif len(seq) == 1:  # you can always add to 1-element seq
            result.update(explore(n, terms[1:], new_seqs))

        elif len(seq) < n and seq[-1] * 2 == seq[-2] + terms[0]:  # is arithmetic?
            result.update(explore(n, terms[1:], new_seqs))

    return result

m = int(raw_input())
terms = sorted(map(int, raw_input().split()))
seqs = [[] for _ in range(m)]

result = explore(len(terms) / m, terms, seqs)

for solution in result:
    print(" ".join(map(str, solution)))

这是一个（不完整的）解决方案，应该对您有所帮助。这个想法是您将术语划分为序列seqs（最初为空）并尝试将术语按升序放入其中一个序列中，以便

1. 每个 seq 都是一个算术序列
2. seq 的第一个元素按升序排列
3. 所有空序列毕竟都是非空序列

Answer 2

您可以将 itertools.combinations 与 Counter dict 一起使用，按降序对列表进行排序：

from itertools import combinations
from collections import Counter
def arith_seq(l, m):
    l.sort(reverse=True)
    terms = len(l) // m
    combs = filter(lambda x: all((x[i + 1] - x[i] == x[1] - x[0]
                                       for i in range(len(x) - 1))), combinations(l, terms))
    out = []
    cn = Counter(l)
    for ele in combs:
        if all(cn[c] > 0 for c in ele):
            out.append(ele[::-1])
            for c in ele:
                cn[c] -= 1
    out.sort()
    return out

输出：

In [15]: ms = [2, 3, 4, 3, 3]
In [16]: for l, m in zip(lsts, ms):
            print(arith_seq(l, m))
   ....:     
[(1, 4, 7), (8, 12, 16)]
[(2, 4, 6), (8, 15, 22), (10, 11, 12)]
[(10, 90, 170, 250), (20, 24, 28, 32), (36, 41, 46, 51), (40, 50, 60, 70)]
[(33, 44, 55, 66), (60, 120, 180, 240), (100, 200, 300, 400)]
[(100, 150, 200, 250), (100, 300, 500, 700), (100, 900, 1700, 2500)]

Answer 3

我有一个时间复杂度低于O(180 mn)的算法。

首先，按升序对序列进行排序。那么

explore(n, m, terms, seqs)
    if m == 0 you find a solution seqs and sort seqs by its first terms. return;
    enumerate 2 elements a, b from the first m+1 elements of terms:
        if there exist a arithmetic sequence S whose first two terms are a, b and length is n:
           explore(n, m - 1, terms - S, seqs + [S])

此算法基于这样一种效果：已排序序列的前m+1 元素必须包含一个算术序列的前两项。

Answer 4

#include <iostream>
using namespace std;
void FormingArray(int a, int b, int n, int arr[])
{    
    for (int i = 0; i < n; i++)
    {
        arr[i] = a + (i * b);
    }
}
void PrintingArray(int n, int arr[])
{
    cout<<"The array is: \n";
    for (int i = 0; i < n; i++)
    {
        cout <<"No."<<(i+1)<<" "<< arr[i] << endl;
    }
}
int SubArray(int arr[] , int n) //Sigma Series
{
    int sum = 0;
    for (int i = 0; i < n; i++)
    {
        sum += arr[i];
    }
    return sum;
    
}
int firstNegItem(int arr[],int n) //First Negative Item
{
    int i = 0;
        while(arr[i]>0)
        {
            i++;
            if (arr[i]<0)
            break;
        }
    return(arr[i+1]);
}
int firstPosItem(int arr[],int n) //First Positive Item
{
        int i = 0;
        while(arr[i]<0)
        {
            i++;
            if (arr[i]>0)
            break;
        }
    return(arr[i+1]);
}
void credit() { cout<<"This program is made by Ali Alsaeid \nThanks for choosing this program <3 \n"; }
int main()
{
    int a; //The First Item
    int b; //Array's Base
    int n; //Number of Items
    int* arr = new int(n); //Sizing Array
    cout << "Enter a (First Item), b (Array's Base), n (Number of Items) \n";
    //Input
    cin >> a >> b >> n;
    FormingArray(a,b,n,arr);
    //Output
    PrintingArray(n,arr); 
    cout << "Submission Array is " << SubArray(arr, n) << endl; //Sigma series
    if (b<0 && a>0)
        cout<<"The first negative item is: "<<firstNegItem(arr,n)<<endl;
    else if (b>0 && a<0)
        cout<<"The first positive item is: "<<firstPosItem(arr,n)<<endl;
    credit();
    return 0;
}