【完全二叉树的权值】

题目

代码1（队列）

#include<bits/stdc++.h>
using namespace std;
#define x first
#define y second
typedef pair<int, int> PII;

const int N = 1e5+10;
int n;
long long a[N];
queue<PII> q;
long long sum[25];
int main()
{
    memset(sum, -1, sizeof(long long) * 25);
    
    cin >> n;
    for(int i = 1; i <= n; i++) cin >> a[i];
    
    q.push({1, 1});
    while(!q.empty())
    {
        int fr = q.front().x;
        int deep = q.front().y;
        if(sum[deep] == -1) sum[deep] = 0;
        sum[deep] += a[fr];
        
        int left = 2 * fr;
        int right = 2 * fr + 1;
        
        if(left <= n)
        {   
            q.push({left, deep+1});
        }
        if(right <= n)
        {
            q.push({right, deep+1});
        }
        
        q.pop();
    }
    
    long long MAX = LLONG_MIN, mdeep;
    for(int i = 1; i <= 20; i++)
    {
        if(sum[i] != -1 && sum[i] > MAX) //sum[i]有负数，而且不知道i的具体范围，初始化又是0，所以需要用-1初始化
        {
            MAX = sum[i];
            mdeep = i;
        }
    }
    
    cout << mdeep;
    
    return 0;
}

代码2（前缀和）

#include <iostream>

// 使用命名空间 std，这样就可以不用每次调用 std:: 来访问标准库函数
using namespace std;

// 定义一个别名 LL，它代表 long long 类型，通常用于表示大整数
typedef long long LL;

// 定义一个常量 N，其值为 100010，作为数组的最大长度
const int N = 100010;

// 定义全局变量
// a[] 数组存储输入的整数序列
// id 用来记录答案中子数组的深度
// n 为整数序列的长度
// ans 用来记录当前找到的最大和，初始化为 INT_MIN
// s[] 数组用于存储前缀和
int a[N], id, n;
LL ans = INT_MIN, s[N];

// 主函数
int main()
{
    // 读入整数序列的长度 n
    cin >> n;
    // 读入整数序列并存入 a[] 数组
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    // 计算前缀和 s[]
    for (int i = 1; i <= n; i++)
        s[i] = s[i - 1] + a[i];

    // 遍历每个可能的子数组长度，从 2 开始，每次翻倍直到超过 n
    // j 为当前子数组的起始位置
    // depth 表示子数组的 "深度"，即进行了几次翻倍操作
    for (int i = 2, j = 1, depth = 1; j <= n; j = i, i *= 2, depth++)
    {
        // 确保 i 不会越界
        i = min(i, n + 1);
        // 如果当前子数组的和大于之前找到的最大和，则更新 ans 和 id
        if (ans < s[i - 1] - s[j - 1])
        {
            ans = s[i - 1] - s[j - 1];
            id = depth;
        }
    }
    // 输出答案中子数组的深度
    cout << id << endl;

    return 0;
}

上面这个抓住前缀和的r用下一层深度的第一个节点来算r = i-1，l就是当前深度的第一个节点。

因此i的迭代用i*=2，j滞后于i，j=i

对于根节点，s[1] - s[0]，r = 1, l = 0，令i = 2, j = 1。

因为这个是完全二叉树，最后一层不一定满，因此最后一个i应该要强制规定到n+1。而j一定是某层第一个节点。最后一次j必定为n+1，所以只要控制 j <= n，以此作循环持续标志就行。

代码3（双指针，其实就是没有前缀和而已）

#include <bits/stdc++.h>

// 使用命名空间 std，这样就可以不用每次调用 std:: 来访问标准库函数
using namespace std;

// 定义一个别名 LL，它代表 long long 类型，通常用于表示大整数
typedef long long LL;

// 定义一个常量 N，其值为 100010，作为数组的最大长度
const int N = 100010;

// 定义全局变量
// a[] 数组存储输入的整数序列
// id 用来记录答案中子数组的深度
// n 为整数序列的长度
// ans 用来记录当前找到的最大和，初始化为 INT_MIN
// s[] 数组用于存储前缀和
int a[N], id, n;
LL ans = INT_MIN;

// 主函数
int main()
{
    // 读入整数序列的长度 n
    cin >> n;
    // 读入整数序列并存入 a[] 数组
    for (int i = 1; i <= n; i++)
        cin >> a[i];

    // 遍历每个可能的子数组长度，从 2 开始，每次翻倍直到超过 n
    // j 为当前子数组的起始位置
    // depth 表示子数组的 "深度"，即进行了几次翻倍操作
    for (int i = 2, j = 1, depth = 1; j <= n; j = i, i *= 2, depth++)
    {
        // 确保 i 不会越界
        i = min(i, n + 1);
        LL s = 0;
        // 计算从 j 到 i - 1 的所有元素之和
        for(int m = j; m <= i-1; m++) s += a[m];
        // 如果当前子数组的和大于已有的最大值，则更新最大值和深度
        if(ans < s)
        {
            ans = s;
            id = depth;
        }
    }
    // 输出答案中子数组的深度
    cout << id << endl;

    return 0;
}