数列还原 网易2017测试工程师编程题

题目：

牛牛的作业簿上有一个长度为n的排列A,这个排列包含了从1到n的n个数，但是因为一些原因，其中有一些位置（不超过10个）看不清了，但是牛牛记得这个数列顺序对的数量是k,顺序对是指满足i<j且A[i]<A[j]的对数，请帮助牛牛计算出，符号这个要求的合法排列数目。输入n,k与序列A,返回可能的存在排列数目。

输入描述：

每个输入包含一个测试用例。每个测试用例的第一行包含两个整数n和k（1<=n<=100，1<=k<=1000000000），接下来的一行，包含n个数字表示排列A，其中等于0的项表示看不清额位置（不超过10个）。

输出描述：

输出一行表示合法排列的数目。

输入例子：

5 5

4 0 0 2 0

输出例子：

2

方法一：通过

#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <unordered_map>
#include <map>
#include <algorithm>
using namespace std;

//输入参数
int n;//输入n个数
int k;//有序对k对
vector<int> a;//输入序列a，包含1~n的n个数，有若干个数（不超过10个）是0
//输出参数
int cnt=0;//合法排列的数目

//输出perm数组，用于测试
void printperm(const vector<vector<int> > &perm)
{
    for(int i=0;i<perm.size();i++)
    {
        for(int j=0;j<perm[0].size();j++)
            cout<<perm[i][j]<<" ";
        cout<<endl;
    }
}

//第一步，选出用于全排列的数
void chooseperm(vector<int> &permuse)
{
    vector<int> permtemp;
    int permnum=0;//需要全排列的数的个数
    int temp=0;
    for(int i=1;i<=n;i++)//初始化为1~n
        permtemp.push_back(i);
    for(int i=0;i<a.size();i++)//移除输入中已有的数
    {
        if(a[i])
        {
            remove(permtemp.begin(),permtemp.end(),a[i]);
            temp++;
        }
    }
    permnum=n-temp;//n-移除的数，即需要全排列的数的个数
    for(int i=0;i<permnum;i++)//得到用于全排列的vector
        permuse.push_back(permtemp[i]);
}

//第二步，对第一步选出的数全排列
void creatperm(vector<vector<int> > &perm,vector<int> &permuse)
{
    do{
        perm.push_back(permuse);
    }while(next_permutation(permuse.begin(), permuse.end()));
}

//第三步，拼接第二步得到的全排列的二维vector和已有的输入
void insertperm(vector<vector<int> > &perminsert,const vector<vector<int> > &perm)
{
    for(int i=0;i<perm.size();i++)
    {
        vector<int> tempinsert;
        int q=0;
        for(int p=0;p<n;p++)
        {
            if(a[p])
                tempinsert.push_back(a[p]);
            else
                tempinsert.push_back(perm[i][q++]);
        }
        perminsert.push_back(tempinsert);
    }
    
}

//第四步，逐行验证其有序对是否为k，统计符合的个数
void count( const vector<vector<int> > &choose)
{
    for(int i=0;i<choose.size();i++)
    {
        int ktemp=0;
        vector<int> temp=choose[i];
        for(int j=0;j<temp.size();j++)
        {
            for(int jj=j+1;jj<temp.size();jj++)
            {
                if(temp[j]<temp[jj])
                    ktemp++;
            }
        }
        if(ktemp==k)
            cnt++;
    }
}

int main(){
    //输入
    cin>>n>>k;
    for(int i=0;i<n;i++)
    {
        int temp;
        cin>>temp;
        a.push_back(temp);
    }
    
    //第一步，选出用于全排列的数
    vector<int> permuse;//用于全排列的数
    chooseperm(permuse);
    // cout<<"用于全排列的数"<<endl;
    // for(int i=0;i<permuse.size();i++)
    //     cout<<permuse[i]<<" ";
    // cout<<endl;
    
    //第二步，对第一步选出的数全排列
    vector<vector<int> > perm;//得到全排列的二维vector
    creatperm(perm,permuse);
    // cout<<"全排列"<<endl;
    // printperm(perm);
    
    //第三步，拼接第二步得到的全排列的二维vector和已有的输入
    vector<vector<int> > perminsert;
    insertperm(perminsert,perm);
    // cout<<"符合模板的排列"<<endl;
    // printperm(perminsert);
    
    //第四步，逐行验证其有序对是否为k，统计符合的个数
    count(perminsert);
    // cout<<"符合的排列个数"<<endl;
    cout<<cnt<<endl;
}

方法二：内存超限:您的程序使用了超过限制的内存

一开始想到的是方法二，方法一是后来改进的，所以也贴出来

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

//输入参数
int n;//输入n个数
int k;//有序对k对
vector<int> a;//输入序列a，包含1~n的n个数，有若干个数（不超过10个）是0
//输出参数
int cnt=0;//合法排列的数目

//输出perm数组，用于测试
void printperm(const vector<vector<int> > &perm)
{
    for(int i=0;i<perm.size();i++)
    {
        for(int j=0;j<perm[0].size();j++)
            cout<<perm[i][j]<<" ";
        cout<<endl;
    }
}

//将1~n全排列，放入二维数组perm
void creatperm(vector<vector<int> > &perm)
{
    vector<int> temp;//1~n的临时vector
    for(int i=1;i<=n;i++)
        temp.push_back(i);
    do{
        perm.push_back(temp);
    }while(next_permutation(temp.begin(), temp.end()));
}

//过滤，刷掉返回false，如果没有刷掉返回true
bool chooseperm(const vector<int> &permtemp)
{
    for(int i=0;i<n;i++)
    {
        if(a[i])
        {
            if(a[i]!=permtemp[i])
                return false;
        }
    }
    return true;
}

//计算cnt
void count( const vector<vector<int> > &choose)
{
    for(int i=0;i<choose.size();i++)
    {
        int ktemp=0;
        vector<int> temp=choose[i];
        for(int j=0;j<temp.size();j++)
        {
            for(int jj=j+1;jj<temp.size();jj++)
            {
                if(temp[j]<temp[jj])
                    ktemp++;
            }
        }
        if(ktemp==k)
            cnt++;
    }
}

int main(){
    //输入
    cin>>n>>k;
    for(int i=0;i<n;i++)
    {
        int temp;
        cin>>temp;
        a.push_back(temp);
    }
    
    //第一步
    //先将1～n全排列（permutation），生成一个二维数组备用（每一行代表一种排序方式）；
    vector<vector<int> >  perm;//用于存放全排列的二维vector
    creatperm(perm);
    // cout<<"全排列:"<<endl;
    // printperm(perm);//测试生成是否正确
    
    //第二步
    //过滤该二维数组，选取满足特定位置上为输入序列中非0数的序列，生成新的二维数组；
    vector<vector<int> > choose;//过滤之后的二维数组
    for(int i=0;i<perm.size();i++)
    {
        if(chooseperm(perm[i]))
            choose.push_back(perm[i]);
    }
    // cout<<"过滤后:"<<endl;
    // printperm(choose);//测试生成是否正确
    
    //第三步
    //逐行验证其有序对是否为k，统计符合的个数；
    count(choose);
    // cout<<"符合的排列个数:"<<endl; 
    cout<<cnt<<endl;
}