Question

我试图创建一个程序，它将从向量1（＆＃39; V1＆＃39;）中乘以3个不相等的位置，并找到最大乘法。我使用3＆＃39;用于＆＃39;计数和写作的循环。该程序得到位置数量N＆＃39;然后全部＆＃39; N＆＃39; N＆＃39; N＆＃39; N＆＃39; ＆quot; input.txt＆＃39;中的数字。之后，它获得了最大的位置＆＃39; max＆＃39;并将其写入＆＃39; output.exe＆＃39;。但我需要保持程序尽可能高效，16mb内存限制和1秒时间限制（我得到1,004秒和33mb）。有更有效的方法吗？

 5 
    10 10 10 -300 - 300

INPUT.TXT

get_feature_names()

Answer 1

通过查看您所做的事情，您必须在给定的输入向量中找到3个数字的最大乘积。

只需对矢量V1进行排序并输出最大值（前3个元素或第1个和后2个元素的乘积）。这在空间和时间上都很有效。

像这样：

sort(V1.begin(),V1.end(),greater<int>())   //sorts in descending order
int n = V1.size()-1;
output max(V1[0] * V1[1] * V1[2], V1[0] * V1[n] * V1[n-1])

Answer 2

第一个，我想到了 - 为什么要存储这些值？您只需要单个最大值 - 无需存储所有这些值，推送它们，而且还需要对它们进行排序。

另一个重要的通知：

你有long long的向量，但是你看过int s。由于您的输入中包含大数字，因此无处不在地使用long long
推回一个项目并将其弹回是毫无意义的 - 你应该在推动之前检查它以避免两次不必要的操作
无论如何，您根本不需要比较i，j，k的等效性 - 根据您的循环限制，它们永远不会相等
当您知道其编号错误时，将项目推送到数组。扩展矢量需要更多时间。您可能希望将其调整为给定大小。

这段代码可能符合你的记忆和时间要求：

int N; 
long long maximum = -9223372036854775807; // Subject to limits.h LLONG_MIN usage
vector<long long> V1;

ifstream file1;
file1.open("input.txt");
file1 >> N;

V1.resize(N);

for (int i = 0; i < N; i++){
    file1 >> V1[i];
}

file1.close();

for (int i = 0; i < N; i++)
    for (int j = 0; j < i; j++)
        for (int k = 0; k < j; k++)
            if (V1[i] * V1[j] * V1[k] > maximum)
                maximum = V1[i] * V1[j] * V1[k];                

ofstream file2;
file2.open("output.txt");
file2 << maximum;
file2.close();

Answer 3

好吧，一旦我看到缩小尺寸和时间，我倾向于删除所有不必要的语言好东西，因为它们确实有助于正确的编程，但只是资源开支。

因此，如果你真的想保留一系列值的不同索引的所有产品，我会建议你丢弃向量，推送和弹出并使用固定大小的数组。

但在低级别优化之前，我们必须考虑所有可能的算法优化。您只希望从列表中获取3种不同值的最大产品。但对于正数，a> = b＆lt; =＆gt; a * c> = b * c且2个负数的乘积为正。

所以最高的产品可能只来自：

3个最高正值的乘积
一个最高正值和2个最低负值（绝对值最高）的乘积
如果没有正值，则为3个最高负值的乘积

所以你甚至不需要加载完整的初始向量，只需保留：

3个最高正值
3个最高负值
2个最低负值

通过在O（n）时间的读取时间存储它们并且仅存储8个值来获得它们。如果你只有5个值，它根本就没有效率，但它会随时间呈线性关系，并且无论你处理什么数值，它都会保持不变。

可能的实施：

#include <iostream>
#include <fstream>
#include <climits>

using namespace std;

class Max3 {
    long long pmax[3];
    long long nmax[3];
    long long nmin[2];

    void push(long long *record, long long val, size_t pos) {
        for(size_t i=0; i<pos; i++) {
            record[i] = record[i + 1];
        }
        record[pos] = val;
    }

    void set(long long *record, long long val, size_t sz) {
        for (size_t i=1; i<sz; i++) {
            if (val < record[i]) {
                push(record, val, i-1);
                return;
            }
        }
        push(record, val, sz -1);
    }

public:
    Max3() {
        size_t i;
        for (i=0; i<sizeof(pmax)/sizeof(pmax[0]); i++) pmax[i] = 0;
        for (i=0; i<sizeof(nmin)/sizeof(nmin[0]); i++) nmin[i] = 0;
        for (i=0; i<sizeof(nmax)/sizeof(nmax[0]); i++) nmax[i] = LLONG_MIN;
    }

    void test(long long val) {
        if (val >= *pmax) {
            set(pmax, val, 3);
        }
        else if (val <= 0) {
            if (val <= *nmin) {
                set(nmin, -val, 2);
            }
            if (val >= *nmax) {
                set(nmax, val, 3);
            }
        }
    }

    long long getMax() {
        long long max = 0, prod, pm;
        if ((prod = pmax[0] * pmax[1] * pmax[2]) > max) max = prod;
        if (pmax[2] > 0) pm = pmax[2];
        else if (pmax[1] > 0) pm = pmax[1];
        else pm = pmax[0];
        if ((prod = nmin[0] * nmin[1] * pm) > max) max = prod;
        if ((prod = nmax[0] * nmax[1] * nmax[2]) > max) max = prod;
        return max;
    }
};


int main() {
    int N;
    long long input;
    Max3 m3;

    ifstream file1;
    file1.open("input.txt");
    file1 >> N;

    for (int i = 0; i < N; i++){
        file1 >> input;
        m3.test(input);
    }
    file1.close();

    ofstream file2;
    file2.open("output.txt");
    file2 << m3.getMax();
    file2.close();
    return 0;
}

代码稍微复杂一些，但程序大小只有35 kb，动态分配很少。

Answer 4

更换＆＃39; for＆＃39;循环与一种矢量1＆＃39; V1＆＃39; （按降序排列），在该程序比较产品＆lt; V1 [0] * V1 [1] * V1 [2]＆＃39;和＆＃39; V1 [0] * V1 [N] * V1 [N - 1＆＃39;，然后在output.txt中输出最大值;

#include <vector> 
#include <fstream> 
#include <iostream> 
#include <algorithm> 
#include <functional>

using namespace std;

int main()
{
int N;
long long max = -9223372036854775807;
int input;

vector<long long> V1;

ifstream file1;
file1.open("input.txt");
file1 >> N;

V1.resize(N);

for (int i = 0; i < N; i++){
    file1 >> V1[i];
}

sort(V1.begin(), V1.end(), greater<int>());

N -= 1;

max = V1[0] * V1[1] * V1[2];

if (max < V1[0] * V1[N] * V1[N - 1])
    max = V1[0] * V1[N] * V1[N - 1];

ofstream file2;
file2.open("output.txt");
file2 << max;
file2.close();
}

@ vish4071 @YeldarKurmangaliyev @SergeBallesta感谢您的帮助！

超出内存限制或时间限制

4 个答案: