Permutations of an int array, using recursion

As you see and say yourself, you simply generate all possible permutations of the 0 2 2 array. There are 6 permutations for an array of length 3, and you correctly get them, but because there are two equal numbers, some of these permutations are equal.

However, apparently what you are required is to do generate only different permutations. Basically, this means that you need a new algorithm.

A simple solution may be to find a way to remove repeating permutations. There may be many approaches to it, starting with simply storing all the permutations and checking if you have already generated a given permutation, or storing the original array index with each number and requiring that the indices of equal number go in increasing order, etc. Or you can organize your recursion in a different way (that's what I would have done). Obviously the complexity of each approach will be different.

With std::next_permutation (which handles repetitions), a non recursive way would be:

void permute(std::vector<int>& nums, std::ostream& out) 
{
    assert(std::is_sorted(nums.begin(), nums.end()));
    do {
        print(nums, out); 
    } while (std::next_permutation(nums.begin(), nums.end()));
}

Demo

You can still transform above code in recursive way:

void permute(std::vector<int>& nums, std::ostream& out) 
{
    print(nums, out); 
    if (std::next_permutation(nums.begin(), nums.end())) { permute(nums, out); }
}

Demo

Your code is perfect and works as expected. The only problem is that your application is sometimes swapping the same digits, for example:

// nums = {0, 2, 2}
swap(nums[n], nums[i]); // n == 1, i == 2
// nums = {0, 2, 2}

Here you can notice that the application will swap 2 and 2, which will not make any difference.

Thus you can try something like this:

#include <iostream>
#include <vector>
#include <fstream>

// This std::vector will store all the elements that have been stored in output.txt
std::vector<std::string> output;

void input(int& m, int& p, int& q)
{
    std::ifstream fin("input.txt");

    fin >> m >> p >> q;

    fin.close();
}

void fillVec(std::vector <int>& elements, int m, int p, int q)
{
    fill_n(elements.begin() + m, p, 1); // filling the std::vectors with correct amount of numbers. The 0's all already there, so I only put the 1's, and the 2's in.
    fill_n(elements.begin() + m + p, q, 2);
}

void print(const std::vector<int>& nums, std::ofstream& fout)
{
    for (int a : nums) { fout << a << ' '; }
    fout << std::endl;
}

void permute(std::vector<int>& nums, int n, std::ofstream& fout)
{
    if (n == nums.size())
    {
        std::string num;

        // Convert nums (int array) to num (std::string)
        for (int i = 0; i < nums.size(); i++) 
        {
            num.push_back(nums[i]);
        }

        // If same element found, return
        for (int i = 0; i < output.size(); i++)
        {
            if (num == output[i]) return;
        }
        print(nums, fout);

        // Insert element to output (std::vector)
        output.push_back(num);
    }
    else
    {
        for (int i = n; i < nums.size(); i++)
        {
            std::swap(nums[n], nums[i]);
            permute(nums, n + 1, fout);
            std::swap(nums[n], nums[i]);
        }
    }
}

int main()
{
    int m, p, q;

    input(m, p, q);

    std::vector <int> elements(m + p + q);
    fillVec(elements, m, p, q);

    std::ofstream fout("output.txt");

    permute(elements, 0, fout);

    fout.close();

    return 0;
}

This code is the same as yours, except I've added a few checks to ensure that there are no duplicate elements. Now:

input.txt

1 0 2

output.txt (after application execution)

0 2 2 
2 0 2 
2 2 0 

...which is desirable.

Also, consider removing the following statement:

using namespace std;

...as it's considered as bad practice.