个人总结的OI、ACM竞赛编码技巧：调试，查错，常数优化

技巧1：封装一个能进行越界检查的Array类

C/C++中数组越界是一件很让人头疼的事。内置的数组类型不进行越界检查，而越界后的行为是未定义的。这就导致有时候程序的行为极其诡异，程序员却迟迟定位不了bug的位置。

C++11提供的std::array类提供了at()成员函数，该函数会在下标越界时抛出一个std::out_of_range类型的异常。std::array重载的operator []不进行越界检查。

但有时我们既想要越界检查，又不想牺牲性能，还不想改变用operator []访问元素的写法。为此我们对数组进行一些封装：

#include <array>
template <class Tp, size_t N>
struct Arr: public std::array<Tp, N> 
{
#ifndef NDEBUG
    Tp& operator [] (size_t idx) { return this->at(idx); }
    const Tp& operator [] (size_t idx) const { return this->at(idx); }
#endif 
};
template <class Tp, size_t N1, size_t N2>
using Arr2 = Arr<Arr<Tp, N2>, N1>;

这里的Arr类继承了std::array的所有成员。在NDEBUG宏未定义时，派生类Arr的operator []覆盖了基类的版本。（顺便黑一波C++坑出风采的const机制）

不需要越界检查时，只需在前边加一句#define NDEBUG即可。（-O2和-O3编译优化下会自动添加NDEBUG，以禁用assert宏）

最后两行是二维数组的一个typedef。注意第11行里边，第二维的大小N2在里层，第一维的大小N1在外层。

在OI、ACM等比赛中，常数优化虽然不像复杂度优化那样重要，但对于某些数据量很大的题目，如果实现时常数太大，也会有TLE的风险。

不过也要注意，常数优化往往是以程序可读性降低为代价的，在实际编程时需要有所取舍。（更何况卡常数的题很容易被喷成毒瘤￢＿￢）

技巧2：arr[x +1] = f(arr[x])的时间常数通常比arr[x] = f(arr[x - 1])更小

举一个简单的例子：

using LL = long long;
LL arr[50000000];
void foo() {
    for (int i = 1; i < size(arr); i++)
        arr[i] = i + arr[i - 1];
}
void bar() {
    for (int i = 0; i < size(arr) - 1; i++)
        arr[i + 1] = i + 1 + arr[i];
}

两种递推的作用是完全等效的，不过对于CPU而言，前一种写法更为“缓存友好”（cache friendly）。当访问arr[i]时，CPU会将紧随其后的一小块缓存起来，访问CPU缓存的速度要快于访问内存。

关于“缓存友好”的详细内容可以参考：https://stackoverflow.com/questions/16699247/what-is-cache-friendly-code

测试程序以及运行结果如下：（编译参数：-std=c++17 -O2）

#include <iostream>
#include <utility>
#include <boost/timer.hpp>

using namespace std;
using LL = long long;
LL arr[50'000'000];
void foo() {
    for (int i = 1; i < size(arr); i++)
        arr[i] = i + arr[i - 1];
}
void bar() {
    for (int i = 0; i < size(arr) - 1; i++)
        arr[i + 1] = i + 1 + arr[i];
}

int main()
{
    for (int i = 0; i < 5; i++)
    {
        cout << "Case " << i + 1 << ":
";
        boost::timer timer;
        foo();
        cout << "foo(): " << timer.elapsed() << '
';
        timer.restart();
        bar();
        cout << "bar(): " << timer.elapsed() << "
";
    }
}

/*
Case 1:
foo(): 0.227
bar(): 0.073
Case 2:
foo(): 0.099
bar(): 0.077
Case 3:
foo(): 0.1
bar(): 0.074
Case 4:
foo(): 0.102
bar(): 0.075
Case 5:
foo(): 0.103
bar(): 0.079
*/

可以看到对于long long类型，bar()的运行时间比foo()短了大约20%（Case 1的数据比较诡异，第一次运行的话耗时都会很长，求大神解释）。

而对于int类型，测试结果表明bar()的运行时间比foo()短了50%~60%，优势更为突出。

——To be continued——