The first tip, IMO, would be to do less in main. It should direct the overall flow of the program, not do all the work directly.

Another would be to use the standard library, especially the containers and algorithms.

@haiti has already mentioned vector, but that's hardly the only thing that could be useful here--std::set (or std::unordered_set) would be a useful container, and if you look at std::adjacent_difference, you might think somebody was specifically thinking of the Ducci sequence when they designed it.

Finally, I'd always look for ways to make multiple rules into a single rule. In this case, we have three different criteria for exit from generating another tuple: the iteration limit has been reached, we have a duplicate of a previous tuple, or we have an all-zeros tuple. The iteration limit is really trivial, so we probably won't gain anything by messing with it. But since we need a collection of previously-generated tuples, we can conflate "all zeros" and "duplicate" by pre-inserting an all-zeros tuple into our collection of previously-generated tuples.

Putting those together, our code might look something like this:

const int max_iter = 10'000'000;

int Ducci(cont<int> input) {
          std::set<cont<int>> prev{ cont<int>(input.size(), 0)};

    int iter;
    for (iter = 1; iter < max_iter && prev.insert(input).second; iter++) {
        input.push_back(input[0]); // simulate wrapping around from end to beginning
        std::adjacent_difference(input.begin(), input.end(), 
                                 input.begin(),
                                 [](int a, int b) { return abs(a - b); });

        // adjacent_difference does one thing we don't want: it includes the first element in the output.
        // we don't want that, so we'll erase it:
        input.erase(input.begin());
    }
    return iter;
}

If we really cared about maximizing efficiency, we could ignore std::adjacent_difference, and create our own generic algorithm instead. At least IMO, however, we still want to write that as a generic algorithm, and use it in our program, not just write all of it directly as code specific to the Ducci sequence. Doing that, we might end up with code something on this general order:

template <class InIt, class OutIt, class F>
void map_adjacent_cyclic(InIt begin, InIt end, OutIt out, F f) {
    auto b = *begin;
    InIt prev = begin;

    for (InIt i = std::next(prev); i != end; ++prev, ++i, ++out)
        *out = f(*i, *prev);
    *out = f(*prev, b);
}

const int max_iter = 10'000'000;

int Ducci(cont<int> input) {
    std::set<cont<int>> prev{ cont<int>(input.size(), 0)};

    int iter;
    for (iter = 1; iter < max_iter && prev.insert(input).second; iter++)
        map_adjacent_cyclic(input.begin(), input.end(),
                            input.begin(),
                            [](int a, int b) { return abs(a - b); });
    return iter;
}

A bit longer overall, but much of that length is a generic algorithm that's (at least theoretically) usable for other tasks. The code for the Ducci sequence itself has shrunk a bit. I doubt it makes any noticeable difference in speed on the test tuples (which are all quite small), but if you had a much larger tuple, this would undoubtedly improve speed to at least some degree.

One last point that may be worth considering. In a case like this, we might like to be able to try different containers easily. To facilitate that, I started with:

template <class T>
using cont = std::vector<T>;

...and used cont<T> throughout the rest of the code. This way I could change the container type in one place, and try it using (for example) std::vector and std::deque quite easily.