使用 VS Code 解决简单的 C++ 问题。如果我尝试通过打印数组进行调试，为什么输出会发生变化？ [重复]

Question

我正在解决https://codeforces.com/problemset/problem/1476/D，我的代码通过了虚拟法官。然而，在我本地的 VS Code 上，如果我尝试使用下面的测试用例，我会遇到以下问题 - 测试用例：

1 6 LRRRLL

问题： 如果我取消注释

print(re1)

函数内的

solve()

行，则输出为

1 3 2 2 1 3 2

。但是，如果我先打印 re1，那么输出结果为

1 3 2 3 1 3 2

（这是正确的）。 我在下面附上了用于竞争性编程的模板。我知道这些模板存在一些“实际项目的不良编码习惯”，但我很想知道是什么原因导致的。或者只是因为 VS Code？

 /*
     42.
*/
#include <bits/stdc++.h>
#include <iostream>
using namespace std;

#define int            long long int
#define F              first
#define S              second
#define pb             push_back
#define si             set <int>
#define vi             vector <int>
#define pii            pair <int, int>
#define vpi            vector <pii>
#define vpp            vector <pair<int, pii>>
#define mii            map <int, int>
#define mpi            map <pii, int>
#define spi            set <pii>
#define endl           "\n"
#define sz(x)          ((int) x.size())
#define all(p)         p.begin(), p.end()
#define double         long double
#define que_max        priority_queue <int>
#define que_min        priority_queue <int, vi, greater<int>>
#define bug(...)       __f (#__VA_ARGS__, __VA_ARGS__)
#define print(a)       for(auto x : a) cout << x << " "; cout << endl
#define print1(a)      for(auto x : a) cout << x.F << " " << x.S << endl
#define print2(a,x,y)  for(int i = x; i < y; i++) cout<< a[i]<< " "; cout << endl
#define ll long long

const int MOD = 998244353;
inline int power(int a, int b, int mod)
{
    a%=MOD;
    int x = 1;
    while (b)
    {
        if (b & 1) {x *= a; x%=mod;}
        a *= a;
        a%=mod;
        b >>= 1;
    }
    return x;
}

template <typename Arg1>
void __f (const char* name, Arg1&& arg1) { cout << name << " : " << arg1 << endl; }
template <typename Arg1, typename... Args>
void __f (const char* names, Arg1&& arg1, Args&&... args)
{
    const char* comma = strchr (names + 1, ',');
    cout.write (names, comma - names) << " : " << arg1 << " | "; __f (comma + 1, args...);
}



//Custom SegTree starts ---------------------------------------------
 
struct segmenttree_subarr{
    int n;
    vector<int> st_subarr;
    vector<int> st_pre;
    vector<int> st_suf;
    vector<int> st_sum;
    void init(int n)
    {
        this->n = n;
        st_subarr.resize(4*n, 0);
        st_pre.resize(4*n, 0);
        st_suf.resize(4*n, 0);
        st_sum.resize(4*n, 0);
    }
    void build(int start, int end, int node, vector<int> &v)
    {
        if(start == end)
        {
            st_sum[node] = v[start];
            st_pre[node] = v[start];
            st_suf[node] = v[start];
            st_subarr[node] = v[start];
            return;
        }
        int mid = (start + end)/2;
        build(start, mid, 2*node+1, v);
        build(mid+1, end, 2*node + 2, v);
        st_sum[node] = st_sum[2*node+1]+ st_sum[2*node +2];
        st_pre[node] = max(st_pre[2*node + 1], st_sum[2*node+1] + st_pre[2*node + 2]);
        st_suf[node] = max(st_suf[2*node + 2], st_sum[2*node+2] + st_suf[2*node + 1]);
        st_subarr[node] = max( st_subarr[2*node+1], max(st_subarr[2*node + 2], st_pre[2*node + 2] + st_suf[2*node + 1]) );
    }
    void build(vector<int> &v)
    {
        build(0, v.size()-1, 0, v);
        //print(st);
    }
    segmenttree_subarr(vector<int> &v)
    {
        int n = v.size();
        init(n);
        build(v);
    }
    void update(int i, int val, int start, int end, int node)
    {
        if(start == end)
        {
            st_sum[node] = val;
            st_suf[node] = val;
            st_pre[node] = val;
            st_subarr[node] = val;
            return;
        }
        int mid = (start + end)/2;
        if(i <= mid)
        {
            update(i,val,start, mid, 2*node +1);
        }
        else{
            update(i, val, mid+1, end, 2*node + 2);
        }
        st_sum[node] = st_sum[2*node+1]+ st_sum[2*node +2];
        st_pre[node] = max(st_pre[2*node + 1], st_sum[2*node+1] + st_pre[2*node + 2]);
        st_suf[node] = max(st_suf[2*node + 2], st_sum[2*node+2] + st_suf[2*node + 1]);
        st_subarr[node] = max( st_subarr[2*node+1], max(st_subarr[2*node + 2], st_pre[2*node + 2] + st_suf[2*node + 1]) );
    }
 
    void update(int index, int val)
    {
        update(index, val, 0, n-1, 0);
    }
 
    pair<pii, pii> query(int l, int r, int start, int end, int node)
    {
        if(start > r || end < l)
        {
            return {{0,0}, {0,0}};
        }
        if(start >=l && end<= r)
        {
            return {{max(r-r,st_subarr[node]), st_sum[node]}, {st_pre[node], st_suf[node]}};
        }
        int mid = (start + end)/2;
        pair<pii,pii> lc = query(l, r, start, mid, 2*node+1);
        pair<pii,pii> rc = query(l,r, mid+1, end, 2*node + 2);
        int sum = lc.F.S + rc.F.S;
        int pre = max(lc.S.F , lc.F.S + rc.S.F);
        int suf = max(rc.S.S, rc.F.S + lc.S.S);
        int ans = max( lc.F.F , max(rc.F.F , rc.S.F + lc.S.S) );
        
        return {{max(ans-ans,ans), sum}, {pre, suf}};
    }
    pair<pii, pii> query(int l, int r)
    {
        
        return query(l,r, 0, n-1, 0);
    }
};



//SEG TREE starts ---------------------------------------------
 
struct segmenttree{
    int n;
    vector<int> st;
    void init(int n)
    {
        this->n = n;
        st.resize(4*n, 0);
    }
    void build(int start, int end, int node, vector<int> &v)
    {
        if(start == end)
        {
            st[node] = v[start];
            return;
        }
        int mid = (start + end)/2;
        build(start, mid, 2*node+1, v);
        build(mid+1, end, 2*node + 2, v);
        st[node] = min(st[2*node+1],st[2*node +2]); //OP
    }
    void build(vector<int> &v)
    {
        build(0, v.size()-1, 0, v);
        //print(st);
    }
    segmenttree(vector<int> &v)
    {
        int n = v.size();
        init(n);
        build(v);
    }
    void update(int i, int val, int start, int end, int node)
    {
        if(start == end)
        {
            st[node] = val;
            return;
        }
        int mid = (start + end)/2;
        if(i <= mid)
        {
            update(i,val,start, mid, 2*node +1);
        }
        else{
            update(i, val, mid+1, end, 2*node + 2);
        }
        st[node] = min(st[2*node+1] , st[2*node + 2]); //OP
    }
 
    void update(int index, int val)
    {
        update(index, val, 0, n-1, 0);
    }
 
    int query(int l, int r, int start, int end, int node)
    {
        if(start > r || end < l)
        {
            return 1e18; //identity x such that a op x = a
        }
        if(start >=l && end<= r)
        {
            return st[node];
        }
        int mid = (start + end)/2;
        int lc = query(l, r, start, mid, 2*node+1);
        int rc = query(l,r, mid+1, end, 2*node + 2);
        return min(lc ,rc); //OP
    } 
    int query(int l, int r)
    {
        return query(l,r, 0, n-1, 0);
    }
};

struct segmenttree_max{
    int n;
    vector<int> st;
    void init(int n)
    {
        this->n = n;
        st.resize(4*n, 0);
    }
    void build(int start, int end, int node, vector<int> &v)
    {
        if(start == end)
        {
            st[node] = v[start];
            return;
        }
        int mid = (start + end)/2;
        build(start, mid, 2*node+1, v);
        build(mid+1, end, 2*node + 2, v);
        st[node] = max(st[2*node+1],st[2*node +2]); //OP
    }
    void build(vector<int> &v)
    {
        build(0, v.size()-1, 0, v);
        //print(st);
    }
    segmenttree_max(vector<int> &v)
    {
        int n = v.size();
        init(n);
        build(v);
    }
    void update(int i, int val, int start, int end, int node)
    {
        if(start == end)
        {
            st[node] = val;
            return;
        }
        int mid = (start + end)/2;
        if(i <= mid)
        {
            update(i,val,start, mid, 2*node +1);
        }
        else{
            update(i, val, mid+1, end, 2*node + 2);
        }
        st[node] = max(st[2*node+1] , st[2*node + 2]); //OP
    }
 
    void update(int index, int val)
    {
        update(index, val, 0, n-1, 0);
    }
 
    int query(int l, int r, int start, int end, int node)
    {
        if(start > r || end < l)
        {
            return -1e18; //identity x such that a op x = a
        }
        if(start >=l && end<= r)
        {
            return st[node];
        }
        int mid = (start + end)/2;
        int lc = query(l, r, start, mid, 2*node+1);
        int rc = query(l,r, mid+1, end, 2*node + 2);
        return max(lc ,rc); //OP
    } 
    int query(int l, int r)
    {
        return query(l,r, 0, n-1, 0);
    }
};


//SEG TREE OVER -----------------------------------
struct MergeTree {
    int n;
    vector<vector<int>> tree;
 
    void build(vector<int> &a, int x, int l, int r) {
        if (l + 1 == r) {
            tree[x] = {a[l]};
            return;
        }
 
        int m = (l + r) / 2;
        build(a, 2 * x + 1, l, m);
        build(a, 2 * x + 2, m, r);
        merge(all(tree[2 * x + 1]), all(tree[2 * x + 2]), back_inserter(tree[x]));
    }
 
    MergeTree(vector<int>& a) : n(a.size()) {
        int SIZE = 1 << ((int)log2(n) + bool(__builtin_popcount(n) - 1));
        tree.resize(2 * SIZE - 1);
        build(a, 0, 0, n);
    }
 
    int count(int lq, int rq, int mn, int mx, int x, int l, int r) {
        if (rq <= l || r <= lq) return 0;
        if (lq <= l && r <= rq) return lower_bound(all(tree[x]), mx) - lower_bound(all(tree[x]), mn);
 
        int m = (l + r) / 2;
        int a = count(lq, rq, mn, mx, 2 * x + 1, l, m);
        int b = count(lq, rq, mn, mx, 2 * x + 2, m, r);
        return a + b;
    }
    //call this to get between a[l .... r] count of values between [mn , mx] included boundaries in O((logn)^2)
    int count(int lq, int rq, int mn, int mx) {
        return count(lq, rq+1, mn, mx+1, 0, 0, n);
    }
};
bool isprime(int n)
{
    for(int i=2; i*i <=n; i++)
    {
        if(n%i == 0)
        {
            return 0;
        }
    }
    return 1;
}


int findGCD(int a1, int b1) {
   if (b1 == 0){
      return a1;
      
   }
   return findGCD(b1, a1 % b1);
}
long long lcm(int a, int b)
{
    return (a / findGCD(a, b)) * b;
}
int fact(int x, int y)
{
    int ans = 1;
    for(int i=2; i<=x; i++)
    {
        if(i == (y)) continue;
        ans*=i;
        ans%=MOD;
    }
    return ans;
}
int factorial[300005];
void precompute_fact(int m = MOD)
{
    factorial[0] = 1;
    for (int i = 1; i <= 300000; i++) {
        factorial[i] = factorial[i - 1] * i % m;
    }
}
int inv(int a, int m = MOD) {
  return a <= 1 ? a : m - (long long)(m/a) * inv(m % a) % m;
}

int nCr(int n, int r, int m = MOD)
{
    //Requires precompute factorial
    if (n<r || r<0) return 0;
    return factorial[n] * inv((factorial[r] * factorial[n - r]) % m, m) % m;
}

//-----------------------------
const int N = 200005;
const int inf = 1e18;
double eps = 0.00001;



void solve()
{
    int n; cin>>n;
    int le[n+2], re1[n+2], lo[n+2], ro[n+2];
    for(int i=0; i<=n+1; i++)
    {
        le[i] = 0; re1[i] = 0; lo[i]=0; ro[i]=0;
    }
    string s; cin>>s; //len = n
    for(int i=1; i<=n; i++)
    {
        if(s[i-1] == 'L')
        {
            le[i] = 1 + lo[i-1];
        }
        else{
            lo[i] = 1 + le[i-1];
        }
    }
    for(int i=n-1; i>=0; i--)
    {
        if(s[i] == 'R')
        {
            re1[i] = 1 + ro[i+1];
        }
        else{
            ro[i] = 1 + re1[i+1];
        }
    }
    
    // print(re1); //UNCOMMENT to get correct answer (below the printed array)
    
    for(int i=0; i<=n; i++)
    {
        cout << le[i] + re1[i] + 1 << " ";
    }
    cout << endl;
}   


//#define MOD 1000000000

int32_t main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

#ifndef ONLINE_JUDGE
    freopen("input.txt",  "r",  stdin);
    freopen("output.txt", "w", stdout);
#endif
    clock_t z = clock();
    // precalc();
    int tt = 1;
    cin >> tt;
    
    for(int i=1;i<=tt; i++)
    {
     // cout<<"Case #"<<i<<": ";
     solve();
    //  cout<<'\n';
    }
    // while (tt--) solve();

    cerr << "Run Time : " << ((double)(clock() - z) / CLOCKS_PER_SEC);
    return 0;
}

我尝试扩展数组的大小以确保我没有触及任何越界内存。我尝试将 re[] 重命名为 re1[] 希望这是一个重复的名称错误。我不知道现在可能是什么错误。

Answer 1

这可能是“堆”及其优先级的原因。也可能是这些习惯造成的。