Question

我已阅读以下问题，但未找到解决问题的方法：

实际问题陈述是： -

Job和Jimmy都在玩数字。 Job向Jimmy提供了一系列数字，并要求他告诉长度为L的非递减序列的最小可能最后数字。

输入格式

第一个输入行包含一个数字，其大小为数组N。

下一行包含N个空格分隔的数组元素。

下一行包含非递减序列的长度，即L。

输出格式

您必须打印序列的最小可能最后编号，如果它们不是长度为L的非递减序列，则打印-1

示例输入
7
9 7 2 5 4 11 12
3
示例输出
11
解释

在样本输入中，长度L = 3的可能的非递减序列是（9,11,12），（7,11,12），（2,5,11），（2,4,11），（2,5,12），（2,4,12），（2,11,12），（5,11,12），（4,11,12），序列的最小最后数字为11（ 2,5,11）和（2,4,11）。因此，答案是11。“

我的代码......

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int fact(int y,int x)
    {
    static int temp=0;
    if(temp==x)
    {
        temp=0;
        return 1;
    }
    else
        {
        ++temp;
        return y*fact((y-1),x);
    }
}

int main() {
    int num,randmax,n,s,q,w last=-1, minlast=-1;

    cin>>n;
    vector<int> a(n);

    for(int i=0;i<n; i++)
        {
        cin>>a[i];
    }
    cin>>s;
    vector<vector<int>> c;
    q=fact(s);
    c.resize(q);
    for(int i = 0 ; i < q ; ++i)
    {
        //Grow Columns by n
        a[i].resize(s);
    }
    w=q;
    randmax=n-1;
    int k=0;
    while(w)
        {
        for(int i=0 ; i<n ; i++){

        }
        num=rand()%randmax; // this works perfect as expected
        c[][i]=a[num];
        }
        w--;
    }
    /*for(int i=0;i<n;i++)
        {
        for(int j=i+1;j<n;j++)
            {
            for(int k=j+1;k<n; k++)
                {
                    if((a[i]<=a[j])&&(a[j]<=a[k]))
                        {
                        last=a[k];

                        if(minlast=-1)
                        {
                            minlast=a[k];
                        }
                        if(last<minlast){
                            minlast=last;
                        }
                    }
            }
        }
    }
    */
    cout<<last;
    return 0;
}

`

我会告诉你我尝试做什么......我想通过在我的一个数组中随机分配数据然后计算它们来映射数据。

我在代码的某个地方迷路了... plz给我一个解决方案...更多的imp。当我需要一个动态嵌套的n循环类型的东西时，有时我被卡住的一个很好的解释...

如果你在我的代码或算法中进行编辑以便我可以了解我的错误在哪里会更有帮助...

先谢谢你的时间......

Answer 1

正如您的链接指出的答案，您可以通过使用数组David来模仿动态数量的for循环，这里提供了一个很好的实现。

对于您提供的实际问题，我认为根本不需要动态数量的for循环。问题是标准的非递减子序列问题，略有变化。

#include <iostream>
#include <fstream>

int N, L;
int arr[100], seq[100];
int bst;

int main() {
    std::ifstream file ("c.txt");

    file >> N;
    for(int n = 0; n < N; ++n)
        file >> arr[n];
    file >> L;
    file.close();

    bst = 1e9;
    for(int i = 0; i <= N; ++i) seq[i] = 1e9;
    for(int i = 0; i < N; ++i)
    {
        int x = 0;
        while(seq[x] < arr[i]) ++x;
        seq[x] = arr[i];
        if(x + 1 >= L) 
            bst = std::min(bst, arr[i]);
    }

    std::cout << bst << std::endl;

    return 0;
}

此代码可以解决您的问题。第一部分进行标准解析和初始化。其余的是LIS问题的变体，它有几个标准算法可以解决它。在这里，我们只检查每当我们扩展长度为L或更长的数组时，我们会看到元素是否小于当前值。

我们如何做n嵌套for循环，其中n是动态的

1 个答案: