xxxxxxxxxx
void build(int node, int start, int end)
{
if(start == end)
{
// Leaf node will have a single element
tree[node] = A[start];
}
else
{
int mid = (start + end) / 2;
// Recurse on the left child
build(2*node, start, mid);
// Recurse on the right child
build(2*node+1, mid+1, end);
// Internal node will have the sum of both of its children
tree[node] = tree[2*node] + tree[2*node+1];
}
}
xxxxxxxxxx
// C++ program to show segment tree operations like construction, query
// and update
#include <bits/stdc++.h>
using namespace std;
// A utility function to get the middle index from corner indexes.
int getMid(int s, int e) { return s + (e -s)/2; }
/* A recursive function to get the sum of values in the given range
of the array. The following are parameters for this function.
st --> Pointer to segment tree
si --> Index of current node in the segment tree. Initially
0 is passed as root is always at index 0
ss & se --> Starting and ending indexes of the segment represented
by current node, i.e., st[si]
qs & qe --> Starting and ending indexes of query range */
int getSumUtil(int *st, int ss, int se, int qs, int qe, int si)
{
// If segment of this node is a part of given range, then return
// the sum of the segment
if (qs <= ss && qe >= se)
return st[si];
// If segment of this node is outside the given range
if (se < qs || ss > qe)
return 0;
// If a part of this segment overlaps with the given range
int mid = getMid(ss, se);
return getSumUtil(st, ss, mid, qs, qe, 2*si+1) +
getSumUtil(st, mid+1, se, qs, qe, 2*si+2);
}
/* A recursive function to update the nodes which have the given
index in their range. The following are parameters
st, si, ss and se are same as getSumUtil()
i --> index of the element to be updated. This index is
in the input array.
diff --> Value to be added to all nodes which have i in range */
void updateValueUtil(int *st, int ss, int se, int i, int diff, int si)
{
// Base Case: If the input index lies outside the range of
// this segment
if (i < ss || i > se)
return;
// If the input index is in range of this node, then update
// the value of the node and its children
st[si] = st[si] + diff;
if (se != ss)
{
int mid = getMid(ss, se);
updateValueUtil(st, ss, mid, i, diff, 2*si + 1);
updateValueUtil(st, mid+1, se, i, diff, 2*si + 2);
}
}
// The function to update a value in input array and segment tree.
// It uses updateValueUtil() to update the value in segment tree
void updateValue(int arr[], int *st, int n, int i, int new_val)
{
// Check for erroneous input index
if (i < 0 || i > n-1)
{
cout<<"Invalid Input";
return;
}
// Get the difference between new value and old value
int diff = new_val - arr[i];
// Update the value in array
arr[i] = new_val;
// Update the values of nodes in segment tree
updateValueUtil(st, 0, n-1, i, diff, 0);
}
// Return sum of elements in range from index qs (quey start)
// to qe (query end). It mainly uses getSumUtil()
int getSum(int *st, int n, int qs, int qe)
{
// Check for erroneous input values
if (qs < 0 || qe > n-1 || qs > qe)
{
cout<<"Invalid Input";
return -1;
}
return getSumUtil(st, 0, n-1, qs, qe, 0);
}
// A recursive function that constructs Segment Tree for array[ss..se].
// si is index of current node in segment tree st
int constructSTUtil(int arr[], int ss, int se, int *st, int si)
{
// If there is one element in array, store it in current node of
// segment tree and return
if (ss == se)
{
st[si] = arr[ss];
return arr[ss];
}
// If there are more than one elements, then recur for left and
// right subtrees and store the sum of values in this node
int mid = getMid(ss, se);
st[si] = constructSTUtil(arr, ss, mid, st, si*2+1) +
constructSTUtil(arr, mid+1, se, st, si*2+2);
return st[si];
}
/* Function to construct segment tree from given array. This function
allocates memory for segment tree and calls constructSTUtil() to
fill the allocated memory */
int *constructST(int arr[], int n)
{
// Allocate memory for the segment tree
//Height of segment tree
int x = (int)(ceil(log2(n)));
//Maximum size of segment tree
int max_size = 2*(int)pow(2, x) - 1;
// Allocate memory
int *st = new int[max_size];
// Fill the allocated memory st
constructSTUtil(arr, 0, n-1, st, 0);
// Return the constructed segment tree
return st;
}
// Driver program to test above functions
int main()
{
int arr[] = {1, 3, 5, 7, 9, 11};
int n = sizeof(arr)/sizeof(arr[0]);
// Build segment tree from given array
int *st = constructST(arr, n);
// Print sum of values in array from index 1 to 3
cout<<"Sum of values in given range = "<<getSum(st, n, 1, 3)<<endl;
// Update: set arr[1] = 10 and update corresponding
// segment tree nodes
updateValue(arr, st, n, 1, 10);
// Find sum after the value is updated
cout<<"Updated sum of values in given range = "
<<getSum(st, n, 1, 3)<<endl;
return 0;
}
//This code is contributed by rathbhupendra
xxxxxxxxxx
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int data, iL, iR;
Node* left;
Node* right;
Node(int iL, int iR): iL(iL), iR(iR) {}
};
Node* constructTree(vector<int> arr, int start, int end) {
if (start == end) {
Node* leaf = new Node(start, end);
leaf->data = arr[start];
return leaf;
}
Node* node = new Node(start, end);
int mid = (start + end) / 2;
node->left = constructTree(arr, start, mid);
node->right = constructTree(arr, mid + 1, end);
node->data = node->left->data + node->right->data;
return node;
}
void display(Node* node) {
if (node->iL == node->iR) {
cout << node->data << " ";
return;
}
display(node->left);
display(node->right);
}
int query(Node* node, int indL, int indR) {
if (node->iL >= indL && node->iR <= indR) {
return node->data;
}
else if (node->iL > indR || node->iR < indL)
return 0;
else {
return (query(node->left, indL, indR) + query(node->right, indL, indR));
}
}
int updateVal(Node* root, int index, int val) {
if (index >= root->iL && index <= root->iR) {
if (index == root->iL && index == root->iR) {
root->data = val;
}
else {
int leftSum = updateVal(root->left, index, val);
int rightSum = updateVal(root->right, index, val);
root->data = leftSum + rightSum;
}
}
return root->data;
}
int main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
vector<int> v = {3, 8, 6, 7, -2, -8, 4, 9};
Node* root1 = constructTree(v, 0, v.size() - 1);
cout << query(root1, 1, 6);
return 0;
}
xxxxxxxxxx
class SGTree
{
vector<int> seg;
public:
SGTree(int n)
{
seg.resize(4 * n + 1);
}
void build(int ind, int low, int high, int arr[])
{
if (low == high)
{
seg[ind] = arr[low];
return;
}
int mid = (low + high) / 2;
build(2 * ind + 1, low, mid, arr);
build(2 * ind + 2, mid + 1, high, arr);
seg[ind] = min(seg[2 * ind + 1], seg[2 * ind + 2]);
}
int query(int ind, int low, int high, int l, int r)
{
// no overlap
if (r < low || high < l)
return INT_MAX;
// complete overlap
if (low >= l && high <= r)
return seg[ind];
// partial overlap
int mid = (low + high) >> 1;
int left = query(2 * ind + 1, low, mid, l, r);
int right = query(2 * ind + 2, mid + 1, high, l, r);
return min(left, right);
}
void update(int ind, int low, int high, int i, int val)
{
if (low == high)
{
seg[ind] = val;
}
int mid = (low + high) >> 1;
if (i <= mid)
update(2 * ind + 1, low, mid, i, val);
else
update(2 * ind + 2, mid + 1, high, i, val);
seg[ind] = min(seg[2 * ind + 1], seg[2 * ind + 2]);
}
};
xxxxxxxxxx
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
bool isPower(long long n)
{
long long f = 1;
while (f <= n) {
if (f == n) {
return false;
}
else {
f *= 2;
}
}
return true;
}
int main()
{
long long n;
long long t;
cin >> n >> t;
vector<unsigned long long>v(n * 2);
long long k;
for (long long i = n; i < n*2; i++) {
cin >> k;
v[i] = k;
}
for (long long i = n - 1; i > 0; i--) {
v[i] = v[2 * i] + v[2 * i + 1];
}
unsigned long long i;
unsigned long long j;
unsigned long long x = 1;
unsigned long long sum = 0;
unsigned long long sum1 = 0;
long long zz;
for (long long l = 0; l < t; l++) {
sum = 0;
x = 1;
sum1 = 0;
cin >> i;
cin >> j;
i += n - 1;
j += n - 1;
zz = i;
if (i == j) {
cout << v[j] << endl;
}
else {
while (isPower(i)) {
if ((i) % 2 == 0) {
sum += v[i];
i = i * x - 1;
x = 1;
}
else {
x = x * 2;
i = i / 2;
}
}
sum += v[i];
x = 1;
while (isPower(j)) {
if (j % 2 == 0) {
sum1 += v[j];
j = j * x - 1;
x = 1;
}
else {
x = x * 2;
j = j / 2;
}
}
sum1 += v[j];
cout << (sum1 - sum + v[zz])% 9223372036854775807 << endl;
}
}
}