Question

我需要以最快的方式做这样的事情（O（1）会很完美）：

for (int j = 0; j < V; ++j)
        {
            if(!visited[j]) required[j]=0;
        }

我提出了这个解决方案：

for (int j = 0; j < V; ++j)
        {
             required[j]=visited[j]&required[j];
        }

这使程序运行速度提高了3倍，但我相信有更好的方法可以做到这一点。我是对的吗？

顺便说一下。 required和visited是动态分配的数组

bool *required;
bool *visited;
required = new bool[V];
visited = new bool[V];

Answer 1

如果您使用的是简单对象列表，则最有可能最适合使用C ++标准库提供的功能。所有现代编译器都能非常有效地识别和优化像valarray和矢量这样的结构。

关于您可以依赖编译器的程度存在很多争论，但有一个保证是，您的编译器是与标准库一起构建的，并且依赖它来实现基本功能（例如您的问题）通常是一个安全的选择。 / p>

永远不要害怕运行自己的时间测试并竞争编译器！这是一项有趣的练习，也是一项越来越难以实现的练习。

构造一个valarray（在c ++ 11及更高版本中高度优化）：

std::valarray<bool> valRequired(required, V);
std::valarray<bool> valVisited(visited, V);
valRequired &= valVisited;

或者，您可以使用transform：

在一行中执行此操作

std::transform(required[0], required[V-1], visited[0], required[0], [](bool r, bool v){ return r & v; })

编辑虽然更少的行不会更快，但您的编译器可能会对此操作进行矢量化。

我也测试了他们的时间：

int main(int argc, const char * argv[]) {
    auto clock = std::chrono::high_resolution_clock{};
    {
        bool visited[5] = {1,0,1,0,0};
        bool required[5] = {1,1,1,0,1};

        auto start = clock.now();
        for (int i = 0; i < 5; ++i) {
            required[i] &= visited[i];
        }
        auto end = clock.now();
        std::cout << "1: " << (end - start).count() << std::endl;
    }

    {
        bool visited[5] = {1,0,1,0,0};
        bool required[5] = {1,1,1,0,1};

        auto start = clock.now();
        for (int i = 0; i < 5; ++i) {
            required[i] = visited[i] & required[i];
        }
        auto end = clock.now();
        std::cout << "2: " << (end - start).count() << std::endl;
    }

    {
        bool visited[5] = {1,0,1,0,0};
        bool required[5] = {1,1,1,0,1};

        auto start = clock.now();
        std::transform(required, required + 4, visited, required, [](bool r, bool v){ return r & v; });
        auto end = clock.now();
        std::cout << "3: " << (end - start).count() << std::endl;
    }

    {
        bool visited[5] = {1,0,1,0,0};
        bool required[5] = {1,1,1,0,1};
        std::valarray<bool> valVisited(visited, 5);
        std::valarray<bool> valrequired(required, 5);

        auto start = clock.now();
        valrequired &= valVisited;
        auto end = clock.now();
        std::cout << "4: " << (end - start).count() << std::endl;
    }
}

输出：

1: 102
2: 55
3: 47
4: 45
Program ended with exit code: 0

Answer 2

在@AlanStokes行中，使用压缩二进制数据并与AVX指令_mm512_and_epi64组合，一次512位。做好准备让你的头发搞砸了。

在布尔数组上使用二进制表达式的最快方法

2 个答案: