在 C++ 中使用大量输入数据时出现分段错误

Question

我想知道我的代码在很大的情况下不起作用的原因。 的输入。 实际上这是来自codingame.com 问题代码正在处理以前的测试用例。 但不是在最后一个输入很大的测试用例中。 我想 100% 完成问题，但最后一个测试用例我被困在 80% 上。

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <iterator>
#include <cmath>

using namespace std;
int ventarr[1024][1024];

void add_edge(int u, int v,int N) {
    for(int i =0;i<N;i++){
        if(ventarr[u][i] != 0){
            continue;
        }
        else{
            ventarr[u][i] = v;
            break;
        }
    }
}

int main()
{
    map<pair<char,char>,char> rules;
    map<int,int> matrix_player_id;
    map<int,int>:: iterator matrix_player_id_itr;
    vector<int>::iterator player_id_itr;
    vector<char>::iterator player_sign_itr;
    map<pair<char, char>, char>::iterator rules_itr;
    char R,P,C,L,S;
    int key_winner = -1;
    int key_loser = -1;
    int key_final = -1;

    rules.insert(make_pair(make_pair('C', 'P'), 'C'));
    rules.insert(make_pair(make_pair('P', 'C'), 'C'));

    rules.insert(make_pair(make_pair('P', 'R'), 'P'));
    rules.insert(make_pair(make_pair('R', 'P'), 'P'));

    rules.insert(make_pair(make_pair('R', 'L'), 'R'));
    rules.insert(make_pair(make_pair('L', 'R'), 'R'));

    rules.insert(make_pair(make_pair('L', 'S'), 'L'));
    rules.insert(make_pair(make_pair('S', 'L'), 'L'));

    rules.insert(make_pair(make_pair('S', 'C'), 'S'));
    rules.insert(make_pair(make_pair('C', 'S'), 'S'));

    rules.insert(make_pair(make_pair('C', 'L'), 'C'));
    rules.insert(make_pair(make_pair('C', 'C'), 'C'));

    rules.insert(make_pair(make_pair('L', 'P'), 'L'));
    rules.insert(make_pair(make_pair('P', 'L'), 'L'));

    rules.insert(make_pair(make_pair('P', 'S'), 'P'));
    rules.insert(make_pair(make_pair('S', 'P'), 'P'));

    rules.insert(make_pair(make_pair('S', 'R'), 'S'));
    rules.insert(make_pair(make_pair('R', 'S'), 'S'));

    rules.insert(make_pair(make_pair('R', 'C'), 'R'));
    rules.insert(make_pair(make_pair('C', 'R'), 'R'));

    int N;
    cin >> N; cin.ignore();
    vector<int> player_id;
    vector<char> player_sign;
    for (int i = 0; i < N; i++) {
        int NUMPLAYER;
        char SIGNPLAYER;
        cin >> NUMPLAYER >> SIGNPLAYER; cin.ignore();
        player_id.push_back(NUMPLAYER);
        player_sign.push_back(SIGNPLAYER);
        matrix_player_id.insert(pair<int, int>(i,NUMPLAYER));
    }
    /*copy(player_id.begin(), player_id.end(), ostream_iterator<int>(std::cout, " "));
    cout << endl;
    copy(player_sign.begin(), player_sign.end(), ostream_iterator<char>(std::cout, " "));*/
    /*for (matrix_player_id_itr = matrix_player_id.begin(); matrix_player_id_itr != matrix_player_id.end(); ++matrix_player_id_itr) { 
        cout << matrix_player_id_itr->first
             << '\t' << matrix_player_id_itr->second <<'\n'; 
    } 
    cout << endl; 
    */

    for(int i = 0; i < log10(N)/log10(2); i++){
        for(int j = 0; j < player_id.size(); j++){
            int k = j+1;
            if(player_sign[j] != player_sign[k]){
                rules_itr = rules.find(make_pair(player_sign[j],player_sign[k]));   
                if(player_sign[k] == rules_itr->second){

                    for(matrix_player_id_itr = matrix_player_id.begin(); matrix_player_id_itr != matrix_player_id.end(); ++matrix_player_id_itr)
                    {
                            if (matrix_player_id_itr->second == player_id[k])
                            {
                                key_winner = matrix_player_id_itr->first;
                                break;
                            }
                    }

                    add_edge(key_winner,player_id[j],N);

                    player_id[j] = 0;
                    player_sign[j] = '0';

                }
                if(player_sign[j] == rules_itr->second){

                    for(matrix_player_id_itr = matrix_player_id.begin(); matrix_player_id_itr != matrix_player_id.end(); ++matrix_player_id_itr)
                    {
                            if (matrix_player_id_itr->second == player_id[j])
                            {
                                key_winner = matrix_player_id_itr->first;
                                break;
                            }
                    }

                    add_edge(key_winner,player_id[k],N);

                    player_id[k] = 0;
                    player_sign[k] = '0';

                }
            }
            else{
                if(player_id[j] < player_id[k]){

                    for(matrix_player_id_itr = matrix_player_id.begin(); matrix_player_id_itr != matrix_player_id.end(); ++matrix_player_id_itr)
                    {
                            if (matrix_player_id_itr->second == player_id[j])
                            {
                                key_winner = matrix_player_id_itr->first;
                                break;
                            }
                    }

                    add_edge(key_winner,player_id[k],N);

                    player_id[k] = 0;
                    player_sign[k] = '0';
                }
                else{
                    for(matrix_player_id_itr = matrix_player_id.begin(); matrix_player_id_itr != matrix_player_id.end(); ++matrix_player_id_itr)
                    {
                            if (matrix_player_id_itr->second == player_id[k])
                            {
                                key_winner = matrix_player_id_itr->first;
                                break;
                            }
                    }

                    add_edge(key_winner,player_id[j],N);

                    player_id[j] = 0;           
                    player_sign[j] = '0';
                }
            }
            ++j;    
        }

        for(int i=0; i<player_id.size(); i++){
                player_id_itr = find(player_id.begin(), player_id.end(), 0);
                player_id.erase(player_id_itr);
                player_sign_itr = find(player_sign.begin(), player_sign.end(), '0');
                player_sign.erase(player_sign_itr);
        }
        for(int i=0; i<player_id.size(); i++){
            cout << player_id[i] << '\t' << player_sign[i] << endl;
        }
        cout << endl;
    }

    for(matrix_player_id_itr = matrix_player_id.begin(); matrix_player_id_itr != matrix_player_id.end(); ++matrix_player_id_itr)
    {
         if (matrix_player_id_itr->second == player_id.front())
         {
            key_final = matrix_player_id_itr->first;
            break;
         }
    }
    cout << player_id.front()<< endl;
    for(int i=0;i<N;i++){
        if(ventarr[key_final][i] != 0){
            if(ventarr[key_final][i+1] != 0){
                cout << ventarr[key_final][i];
                cout << " ";
            }
            else{
                 cout << ventarr[key_final][i];
            }
        }
        else{
            continue;
        }
    }

}

Answer 1

在代码的各个部分中，您正在分配值并使用可以运行到输入数字N的索引来寻址固定大小的数组ventarr ，正如您所提到的，它可能非常大。 如果您的N大于或等于 1024，则add_edge将丢弃 memory。

如果出于任何原因必须在那里使用固定大小的数组，则需要为N添加上限检查。 如果N需要大到一个合理的大小，那么看看你是否可以动态地将你的数组分配到那个大小，或者增加当前的最大值。

我看了一下这个问题，它有一个N的边界规范：

N 是 2^k 值 (2, 4, 8, 16, ..., 1024)

2≤N≤1024

在这种情况下，将您的固定数组维度增加到vetarr[1025][1025]并再试一次。 但是，您确实需要确保输入的N值不超出指定范围。