Question

问题声明 您将得到严格递增的整数A1，A2，…，AN序列。您的任务是压缩此序列。

此序列的压缩形式是一系列范围，这些范围之间用逗号分隔（字符“，”）。范围可以是整数，也可以是由三个点（字符串“ ...”）分隔的一对整数。当将压缩形式的每个范围a ... b解压缩为子序列（a，a + 1，...，b）时，我们应该再次获得（逗号分隔）序列A。

对于A的每个最大连续子序列（a，a + 1，…，b），使得b≥a+ 2，A的压缩形式必须包含范围a ... b；如果b≤a+ 1，则不应将此类序列压缩到一个范围内。如果连续子序列不能被其旁边的A的至少一个元素扩展，则该子序列最大。可以证明，任何序列的压缩形式都是唯一的（即定义明确的）。

输入输入的第一行包含一个整数T，表示测试用例的数量。 T测试用例的描述如下。每个测试用例的第一行包含一个整数N。第二行包含N个以空格分隔的整数A1，A2，…，AN。输出量对于每个测试用例，打印一行包含一个字符串的行-给定序列的压缩形式。

约束

1≤T≤100
1≤N≤100
1 ≤ Ai ≤ 1000 for each valid i
A1 < A2 < …... <AN

子任务

子任务1（100分）：原始约束

示例输入

3
12
1 2 3 5 6 8 9 10 11 12 15 17
4
4 5 7 8
1
4

示例输出

1...3,5,6,8...12,15,17
4,5,7,8
4

我的代码：

#include <bits/stdc++.h>

using namespace std;
bool b[1005];
int a[1005];
int main()
{
    int test, i, j, size, count;
    cin >> test;
    while (test--)
    {

        for (i = 0; i < 1005; i++)
            b[i] = false;

        cin >> size;

        for (i = 0; i < size; i++)
        {
            cin >> a[i];
            b[a[i]] = true;
        }

        for (i = 0; i < 1005; i++)
        {
            if (b[i] == true)
            {
                cout << i;
                j = i;
                count = 0;
                while (b[j] == true)
                {
                    count++;
                    j++;
                }

                if (count > 2)
                {
                    i = j;
                    if ((j - 1) != a[size - 1])
                        cout << "..." << i - 1 << ",";
                    else
                        cout << "..." << i - 1;
                }
                if (count == 2)
                {
                    i = j;
                    if ((j - 1) != a[size - 1])
                        cout << "," << i - 1 << ",";
                    else
                        cout << "," << i - 1;
                }
                if (count == 1 && ((j - 1) != a[size - 1]))
                    cout << ",";
            }
        }
    }
    return 0;
}
}

我的问题： 上面的代码可以在我的设备上完美运行，并提供所需的输出。但是当我将解决方案提交给在线法官，说分割错误。可以肯定的是，从根本上来讲，我是错误地访问了内存。你能告诉我它在哪里吗？

Answer 1

b被定义为bool [1005]

在这部分

for(i=0 ; i<4000 ; i++)
    b[i] = false;

您正在写入错误值4000次，超出数组大小。编译器允许覆盖数组，但在运行时将具有未定义的行为。简而言之：它可能会或不会导致段错误。

Answer 2

鉴于输入数据位于文件input.txt中，这是另一种方法：

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

class Reader {
public:
    Reader(const std::string& filename) :
        filename_(std::move(filename)), is_(filename_)
    {
        is_.exceptions( std::ifstream::failbit | std::ifstream::badbit );
    }

    int get_N() {
        int N;
        is_ >> N;
        return N;
    }

    std::vector<int> get_ints(int N) {
        std::vector<int> v;

        v.reserve(N);
        for (int i = 0; i < N; i++ ) {
            int value;
            is_ >> value;
            v.push_back(value);
        }
        return v;
    }

    int get_num_cases() {
        int num_cases;
        is_ >> num_cases;
        return num_cases;
    }

private:
    std::string filename_;
    std::ifstream is_;
};

bool start_range_cur( std::vector<int> &v, int j, int N )
{
    if ( j>= (N - 2) ) return false;
    return ((v[j+1] - v[j]) == 1) && ((v[j+2] - v[j+1]) == 1);
}

bool in_range_cur( std::vector<int> &v, int j )
{
    return (v[j+1] - v[j]) == 1;
}

void print_range( int min, int max, bool print_comma)
{
    std::cout << min << ".." << max;
    if (print_comma) std::cout << ",";
}

void print_single(int val, bool print_comma)
{
    std::cout << val;
    if (print_comma) {
        std::cout << ",";
    }
}

int main() {
    Reader is {"input.txt"};

    int num_cases = is.get_num_cases();
    for (int i = 0; i < num_cases; i++) {
        int N = is.get_N();
        std::vector<int> v = is.get_ints(N);
        bool in_range = false;
        int range_start;
        for( int j = 0; j< N; j++ ) {
            if (in_range) {
                if (j == (N - 1)) {
                    print_range(range_start, v[j], false);
                }
                else if (in_range_cur(v, j)) {
                    continue;
                }
                else {
                    print_range(range_start, v[j], true);
                    in_range = false;
                }
            }
            else {
                if (j == (N - 1)) {
                    print_single(v[j], false);
                }
                else if (start_range_cur(v, j, N)) {
                    in_range = true;
                    range_start = v[j];
                }
                else {
                    print_single(v[j], true);
                }
            }
        }
        std::cout << '\n';
    }

    return 0;
}

为什么下面的代码会导致分段错误（SIGSEGV）？

2 个答案: