Question

我一直在努力理解query()函数中最后6行的逻辑。

这是关于spoj的问题GSS1的代码。

解决方案link

#include <cstdio>
#include <algorithm>
#define MAX 70000

using namespace std;

struct no {
int lsum, rsum, msum;
};

int array[ MAX + 1 ], sums[ MAX + 1 ];
no tree[ 4 * MAX + 1 ];

 void init( int node, int i, int j ) {
if ( i == j ) {
    tree[ node ] = ( ( no ) { array[ i ], array[ i ], array[ i ] } );
}
else {
    init( node * 2, i, ( i + j ) / 2 );
    init( node * 2 + 1, ( i + j ) / 2 + 1, j );
    no left = tree[ node * 2 ], right = tree[ node * 2 + 1 ];
    tree[ node ].lsum = max( left.lsum, sums[ ( i + j ) / 2 ] - sums[ i - 1 ] + right.lsum );
    tree[ node ].rsum = max( right.rsum, sums[ j ] - sums[ ( i + j ) / 2 ] + left.rsum );
    tree[ node ].msum = max( left.msum, max( right.msum, left.rsum + right.lsum ) );
}}

 no query( int node, int a, int b, int i, int j ) {
if ( a == i && b == j ) {
    return tree[ node ];
}
else if ( j <= ( a + b ) / 2 ) {
    return query( node * 2, a, ( a + b ) / 2, i, j );
}
if ( i > ( a + b ) / 2 ) {
    return query( node * 2 + 1, ( a + b ) / 2 + 1, b, i, j );
}
no left = query( node * 2, a, ( a + b ) / 2, i, ( a + b ) / 2 );
no right = query( node * 2 + 1, ( a + b ) / 2 + 1, b, ( a + b ) / 2 + 1, j );
return ( ( no ) {
            max( left.lsum, sums[ ( a + b ) / 2 ] - sums[ i - 1 ] + right.lsum ),
            max( right.rsum, sums[ b ] - sums[ ( a + b ) / 2 ] + left.rsum ),
            max( left.msum, max( right.msum, left.rsum + right.lsum ) )
            } ); }

int main() {
int i, N, q, l, r;
scanf( "%d", &N );
for ( i = 0; i < N; ++i ) {
    scanf( "%d", array + i );
    if ( i == 0 ) {
        sums[ i ] = array[ i ];
    }
    else {
        sums[ i ] = sums[ i - 1 ] + array[ i ];
    }
}
init( 1, 0, N - 1 );
scanf( "%d", &q );
for ( i = 0; i < q; ++i ) {
    scanf( "%d%d", &l, &r );
    --l;
    --r;
    printf( "%d\n", query( 1, 0, N - 1, l, r ).msum );
}
return 0; }

对于no = left＆amp;＆amp;＆amp; no = right，返回查询函数。

任何人都建议更好的实现/教程fr段树。

我无法在实现数据结构时可视化这些递归。有提示吗？

Answer 1

对于no = left＆amp;＆amp;＆amp; no = right，返回查询功能

这是您查询的细分受众群进入两个孩子的情况。

假设您有一个覆盖间隔1..n的节点，并且有2个子节点1 .. n / 2和n / 2 + 1 ..n。如果要查询某个区间[a，b]，使得＆lt; = n / 2＆lt; b然后你需要从左分支和右分支得到结果并将它们组合起来（换句话说，将查询分成[a，n / 2]和[n / 2 + 1，b]得到2个结果并组合它们。

为了提高效率，你可以证明任何查询都只能有一个分割，因为间隔现在正在触及边缘（所以当你总是遍历其中一个孩子时，另一个被忽略或完全落入查询并返回下一个递归步骤。）

该代码用于非常有效的实现（您不存储指向子节点的指针，节点范围是隐式的）。如果您正在尝试学习/调试寻找更明确地存储事物的东西，或者自己编写一个。至少在代码中缩进代码，将变量名称更改为更具可读性的名称，并将(a+b)/2替换为middle。这应该使代码更容易理解。还可以在纸上绘制结构（总是有帮助）。

在段树中查询

1 个答案: