从序列中选择三个数字，使它们的总和小于一个值

Question

Let's say I have an sequence of numbers :

1, 2, 3, 4, 5, 2, 4, 1

I wonder about algorithm which could say how many possible ways of choosing 3 numbers from sequence above exist, such that their sum doesn't exceed 7?

I was asked to write a program to solve the problem. Are there any program techniques I can use?

I will be appreciate your answer!

Answer 1

To get the lowest 3-sum possible, you will simply need to choose the lowest 3 numbers. If this number is lower than the given number - you are done. Otherwise you can answer - there is no such solution, since every other sum you get is bigger than the one you just found, which by its own is bigger than the desired number.

If you wish to find out "How many different summations there are to a number smaller than the given number", that's a different problem, that can be solved using Dynamic Programming in O(n*number*3) = O(n*number) :

f(x,i,3) = (x <+ 0 ? 0 : 1)
f(_,n,_) = 0 //out of bound
f(x,i,used) = f(x-arr[i],i+1, used + 1) + f(x,i+1,used)

Invoke with f(number,0,0)

Answer 2

The following program written in Python 3.4.1 gives one solution that may help you with the problem.

NUMBERS = 1, 2, 3, 4, 5, 2, 4, 1
TARGET = 7
USING = 3

def main():
    candidates = sorted(NUMBERS)[:USING]
    if sum(candidates) <= TARGET:
        print('Your numbers are', candidates)
    else:
        print('Your goal is not possible.')

if __name__ == '__main__':
    main()

---

Edit:

Based on your comment that you want all possible solutions, the following provides this information along with the number of unique solutions. A solution is considered to be the same as another if both have the same numbers in them (regardless of order).

import itertools

NUMBERS = 1, 2, 3, 4, 5, 2, 4, 1
TARGET = 7
USING = 3

def main():
    # Find all possible solutions.
    solutions = []
    for candidates in itertools.combinations(NUMBERS, USING):
        if sum(candidates) <= TARGET:
            print('Solution:', candidates)
            solutions.append(candidates)
    print('There are', len(solutions), 'solutions to your problem.')
    # Find all unique solutions.
    unique = {tuple(sorted(answer)) for answer in solutions}
    print('However, only', len(unique), 'answers are unique.')
    for answer in sorted(unique):
        print('Unique:', answer)

if __name__ == '__main__':
    main()

Answer 3

Use recursion. A C++ solution:

void count(std::vector<int>& arr, int totalTaken, int index, int currentSum, int expectedSum, int *totalSolutions){
        if (index == arr.size()) return;
        if (totalTaken == 3)
            if (currentSum <= expectedSum)
                (*totalSolutions)++;
            else return;
        count(arr, totalTaken++, idex++, curentSum+arr[index],expectedSum, totalSolutions)
        count(arr, totalTaken, index++, currentSum, expectedSum, totalSolutions)
    }

Call with count(your_vector,0,0,0,expectedSum,ptr2int) after the function has exectuted, you will have your result stored in *ptr2int

Answer 4

It is possible to obtain O(n^2) time complexity using two pointers technique:

1. Sort the numbers.
2. Let's fix the middle number. Let's assume that its index is mid.
3. For a fixed mid, you can maintain two indices: low and high. They correspond to the smallest and the biggest number in a sum. Initially, low = mid - 1 and high = mid + 1.
4. Now you can increment high by one in a loop and decrement low as long as the sum of 3 numbers is greater then S. For a fixed high and mid, low shows how many numbers can added to a[mid] and a[high] so that thier sum is <= S. Note that for a fixed mid, high can be incremented O(n) times and low can be decremented only O(n) times. Thus, time complexity is O(n^2).

This algorithm requires only O(1) additional space(for low, mid and high indices).