给定N个棋盘都为“白色”，并且有多个查询Q。查询有两种类型：
- 更新：给定范围为[L，R]的索引。用L和R之间的相反颜色绘制所有棋子(即，白色棋子应涂成黑色，黑色棋子应涂成白色)。
- 获取：给定范围为[L，R]的索引。找出L和R之间的黑色块数。
让我们用“ 0”表示“白色”块，用“ 1”表示“黑色”块。
先决条件：段树|延迟传播
例子 ：
Input : N = 4, Q = 5
Get : L = 0, R = 3
Update : L = 1, R = 2
Get : L = 0, R = 1
Update : L = 0, R = 3
Get : L = 0, R = 3
Output : 0
1
2
解释 ：
Query1：A [] = {0，0，0，0}由于最初所有块都是白色，所以黑色块的数量将为零。
Query2：A [] = {0，1，1，0}
Query3：[0，1] = 1中的黑色块数
Query4：在[0，3]，A [] = {1，0，0，1}中将颜色更改为其相反的颜色
Query5：[0，3] = 2中的黑色块数
天真的方法：
Update(L，R)：从L到R遍历子数组，并更改所有片段的颜色(即，将0更改为1，将1更改为0)
Get(L，R)：要获取黑色块的数量，只需计算[L，R]范围内的黑色块的数量。
update和getBlackPieces()函数都将具有O(N)时间复杂度。最坏情况下的时间复杂度是O(Q * N)，其中Q是查询数，N是棋盘数。
高效的方法：
解决此问题的一种有效方法是使用分段树，该树可以减少将update和getBlackPieces函数更新为O(LogN)的时间复杂度。
构建结构：根据片段的颜色，段树的每个叶节点将包含0或1(即，如果片段为黑色，则节点将包含1，否则为0)。内部节点将包含其左子节点和右子节点的总和或黑色块的数目。因此，根节点将为我们提供整个数组[0..N-1]中的黑色块总数
更新结构：点更新需要O(Log(N))时间，但是当存在范围更新时，请使用惰性传播优化更新。下面是修改后的更新方法。
UpdateRange(ss, se)
1. If current node's range lies completely in update query range.
...a) Value of current node becomes the difference of total count
of black pieces in the subtree of current node and current
value of node, i.e. tree[curNode] = (se - ss + 1) - tree[curNode]
...b) Provide the lazy value to its children by setting
lazy[2*curNode] = 1 - lazy[2*curNode]
lazy[2*curNode + 1] = 1 - lazy[2*curNode + 1]
2. If the current node's lazy value is not zero, first update
it and provide lazy value to children.
3. Partial Overlap of current node's range with query range
...a) Recurse for left and right child
...b) Combine the resutls of step (a)
查询结构：通过检查待处理的更新并更新它们以获取正确的查询输出，查询结构还将以与更新结构相同的方式进行一些更改。
下面是上述方法的实现
C++
// C code for queries on chessboard
#include
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 given range of
the array. The following are
parameters for this function.
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., tree[si]
qs & qe --> Starting and ending
indexes of query range */
int getSumUtil(int* tree, int* lazy, int ss,
int se, int qs, int qe, int si)
{
// If lazy flag is set for current node
// of segment tree, then there are some
// pending updates. So we need to make
// sure that the pending updates are done
// before processing the sub sum query
if (lazy[si] != 0)
{
// Make pending updates to this node.
// Note that this node represents
// sum of elements in arr[ss..se]
tree[si] = (se - ss + 1) - tree[si];
// checking if it is not leaf node
// because if it is leaf node then
// we cannot go further
if (ss != se)
{
// Since we are not yet updating
// children os si, we need to set
// lazy values for the children
lazy[si * 2 + 1] =
1 - lazy[si * 2 + 1];
lazy[si * 2 + 2] =
1 - lazy[si * 2 + 2];
}
// unset the lazy value for current
// node as it has been updated
lazy[si] = 0;
}
// Out of range
if (ss > se || ss > qe || se < qs)
return 0;
// At this point we are sure that pending
// lazy updates are done for current node.
// So we can return value (same as it was
// for query in our previous post)
// If this segment lies in range
if (ss >= qs && se <= qe)
return tree[si];
// If a part of this segment overlaps
// with the given range
int mid = (ss + se) / 2;
return getSumUtil(tree, lazy, ss, mid,
qs, qe, 2 * si + 1) +
getSumUtil(tree, lazy, mid + 1,
se, qs, qe, 2 * si + 2);
}
// Return sum of elements in range from index
// qs (query start) to qe (query end). It
// mainly uses getSumUtil()
int getSum(int* tree, int* lazy, int n,
int qs, int qe)
{
// Check for erroneous input values
if (qs < 0 || qe > n - 1 || qs > qe)
{
printf("Invalid Input");
return -1;
}
return getSumUtil(tree, lazy, 0, n - 1,
qs, qe, 0);
}
/* si -> index of current node in segment tree
ss and se -> Starting and ending indexes of
elements for which current
nodes stores sum.
us and ue -> starting and ending indexes
of update query */
void updateRangeUtil(int* tree, int* lazy, int si,
int ss, int se, int us, int ue)
{
// If lazy value is non-zero for current node
// of segment tree, then there are some
// pending updates. So we need to make sure that
// the pending updates are done before making
// new updates. Because this value may be used by
// parent after recursive calls (See last line
// of this function)
if (lazy[si] != 0) {
// Make pending updates using value stored
// in lazy nodes
tree[si] = (se - ss + 1) - tree[si];
// checking if it is not leaf node because if
// it is leaf node then we cannot go further
if (ss != se)
{
// We can postpone updating children
// we don't need their new values now.
// Since we are not yet updating children
// of si, we need to set lazy flags for
// the children
lazy[si * 2 + 1] = 1 - lazy[si * 2 + 1];
lazy[si * 2 + 2] = 1 - lazy[si * 2 + 2];
}
// Set the lazy value for current node
// as 0 as it has been updated
lazy[si] = 0;
}
// out of range
if (ss > se || ss > ue || se < us)
return;
// Current segment is fully in range
if (ss >= us && se <= ue) {
// Add the difference to current node
tree[si] = (se - ss + 1) - tree[si];
// same logic for checking leaf
// node or not
if (ss != se)
{
// This is where we store values in
// lazy nodes, rather than updating
// the segment tree itelf. Since we
// don't need these updated values now
// we postpone updates by storing
// values in lazy[]
lazy[si * 2 + 1] = 1 - lazy[si * 2 + 1];
lazy[si * 2 + 2] = 1 - lazy[si * 2 + 2];
}
return;
}
// If not completely in rang, but overlaps,
// recur for children
int mid = (ss + se) / 2;
updateRangeUtil(tree, lazy, si * 2 + 1,
ss, mid, us, ue);
updateRangeUtil(tree, lazy, si * 2 + 2,
mid + 1, se, us, ue);
// And use the result of children calls
// to update this node
tree[si] = tree[si * 2 + 1] + tree[si * 2 + 2];
}
// Function to update a range of values
// in segment tree
/* us and eu -> starting and ending indexes
of update query ue -> ending index
of update query, diff -> which we need
to add in the range us to ue */
void updateRange(int* tree, int* lazy,
int n, int us, int ue)
{
updateRangeUtil(tree, lazy, 0, 0, n - 1, us, ue);
}
// 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* tree, int si)
{
// If there is one element in array, store
// it in current node of segment tree and return
if (ss == se)
{
tree[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);
tree[si] = constructSTUtil(arr, ss, mid,
tree, si * 2 + 1) +
constructSTUtil(arr, mid + 1,
se, tree, si * 2 + 2);
return tree[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 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* tree = new int[max_size];
// Fill the allocated memory st
constructSTUtil(arr, 0, n - 1, tree, 0);
// Return the constructed segment tree
return tree;
}
/* Function to construct lazy array for
segment tree. This function allocates
memory for lazy array */
int* constructLazy(int arr[], int n)
{
// Allocate memory for lazy array
// Height of lazy array
int x = (int)(ceil(log2(n)));
// Maximum size of lazy array
int max_size = 2 * (int)pow(2, x) - 1;
// Allocate memory
int* lazy = new int[max_size];
// Return the lazy array
return lazy;
}
// Driver program to test above functions
int main()
{
// Initialize the array to zero
// since all pieces are white
int arr[] = { 0, 0, 0, 0 };
int n = sizeof(arr) / sizeof(arr[0]);
// Build segment tree from given array
int* tree = constructST(arr, n);
// Allocate memory for Lazy array
int* lazy = constructLazy(arr, n);
// Print number of black pieces
// from index 0 to 3
cout << "Black Pieces in given range = "
<< getSum(tree, lazy, n, 0, 3) << endl;
// UpdateRange: Change color of pieces
// from index 1 to 2
updateRange(tree, lazy, n, 1, 2);
// Print number of black pieces
// from index 0 to 1
cout << "Black Pieces in given range = "
<< getSum(tree, lazy, n, 0, 1) << endl;
// UpdateRange: Change color of
// pieces from index 0 to 3
updateRange(tree, lazy, n, 0, 3);
// Print number of black pieces
// from index 0 to 3
cout << "Black Pieces in given range = "
<< getSum(tree, lazy, n, 0, 3) << endl;
return 0;
} Java
// Java implementation of the approach
import java.io.*;
import java.util.*;
class GFG
{
// A utility function to get the
// middle index from corner indexes.
static int getMid(int s, int e)
{
return s + (e - s) / 2;
}
/*
* A recursive function to get the sum of
values in given range of the array.
* The following are parameters for this function.
* 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., tree[si]
* qs & qe --> Starting and ending
* indexes of query range
*/
static int getSumUtil(int[] tree, int[] lazy, int ss,
int se, int qs, int qe, int si)
{
// If lazy flag is set for current node
// of segment tree, then there are some
// pending updates. So we need to make
// sure that the pending updates are done
// before processing the sub sum query
if (lazy[si] != 0)
{
// Make pending updates to this node.
// Note that this node represents
// sum of elements in arr[ss..se]
tree[si] = (se - ss + 1) - tree[si];
// checking if it is not leaf node
// because if it is leaf node then
// we cannot go further
if (ss != se)
{
// Since we are not yet updating
// children os si, we need to set
// lazy values for the children
lazy[si * 2 + 1] = 1 - lazy[si * 2 + 1];
lazy[si * 2 + 2] = 1 - lazy[si * 2 + 2];
}
// unset the lazy value for current
// node as it has been updated
lazy[si] = 0;
}
// Out of range
if (ss > se || ss > qe || se < qs)
return 0;
// At this point we are sure that pending
// lazy updates are done for current node.
// So we can return value (same as it was
// for query in our previous post)
// If this segment lies in range
if (ss >= qs && se <= qe)
return tree[si];
// If a part of this segment overlaps
// with the given range
int mid = (ss + se) / 2;
return getSumUtil(tree, lazy, ss, mid, qs, qe, 2 * si + 1)
+ getSumUtil(tree, lazy, mid + 1, se, qs, qe, 2 * si + 2);
}
// Return sum of elements in range from index
// qs (query start) to qe (query end). It
// mainly uses getSumUtil()
static int getSum(int[] tree, int[] lazy, int n, int qs, int qe)
{
// Check for erroneous input values
if (qs < 0 || qe > n - 1 || qs > qe)
{
System.out.println("Invalid Input");
return -1;
}
return getSumUtil(tree, lazy, 0, n - 1, qs, qe, 0);
}
/*
* si -> index of current node in segment tree
* ss and se -> Starting and ending indexes of
* elements for which current
* nodes stores sum.
* us and ue -> starting and ending indexes of
* update query
*/
static void updateRangeUtil(int[] tree, int[] lazy, int si,
int ss, int se, int us, int ue)
{
// If lazy value is non-zero for current node
// of segment tree, then there are some
// pending updates. So we need to make sure that
// the pending updates are done before making
// new updates. Because this value may be used by
// parent after recursive calls (See last line
// of this function)
if (lazy[si] != 0)
{
// Make pending updates using value stored
// in lazy nodes
tree[si] = (se - ss + 1) - tree[si];
// checking if it is not leaf node because if
// it is leaf node then we cannot go further
if (ss != se)
{
// We can postpone updating children
// we don't need their new values now.
// Since we are not yet updating children
// of si, we need to set lazy flags for
// the children
lazy[si * 2 + 1] = 1 - lazy[si * 2 + 1];
lazy[si * 2 + 2] = 1 - lazy[si * 2 + 2];
}
// Set the lazy value for current node
// as 0 as it has been updated
lazy[si] = 0;
}
// out of range
if (ss > se || ss > ue || se < us)
return;
// Current segment is fully in range
if (ss >= us && se <= ue)
{
// Add the difference to current node
tree[si] = (se - ss + 1) - tree[si];
// same logic for checking leaf
// node or not
if (ss != se)
{
// This is where we store values in
// lazy nodes, rather than updating
// the segment tree itelf. Since we
// don't need these updated values now
// we postpone updates by storing
// values in lazy[]
lazy[si * 2 + 1] = 1 - lazy[si * 2 + 1];
lazy[si * 2 + 2] = 1 - lazy[si * 2 + 2];
}
return;
}
// If not completely in rang, but overlaps,
// recur for children
int mid = (ss + se) / 2;
updateRangeUtil(tree, lazy, si * 2 + 1, ss, mid, us, ue);
updateRangeUtil(tree, lazy, si * 2 + 2, mid + 1, se, us, ue);
// And use the result of children calls
// to update this node
tree[si] = tree[si * 2 + 1] + tree[si * 2 + 2];
}
// Function to update a range of values
// in segment tree
/*
* us and eu -> starting and ending indexes
* of update query
* ue -> ending index of update query
* diff -> which we need to add in the range
* us to ue
*/
static void updateRange(int[] tree, int[] lazy,
int n, int us, int ue)
{
updateRangeUtil(tree, lazy, 0, 0, n - 1, us, ue);
}
// A recursive function that constructs
// Segment Tree for array[ss..se]. si is
// index of current node in segment tree st
static int constructSTUtil(int arr[], int ss,
int se, int[] tree, int si)
{
// If there is one element in array, store
// it in current node of segment tree and return
if (ss == se)
{
tree[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);
tree[si] = constructSTUtil(arr, ss, mid, tree, si * 2 + 1)
+ constructSTUtil(arr, mid + 1, se, tree, si * 2 + 2);
return tree[si];
}
/*
* Function to construct segment tree from
given array. This function allocates memory
for segment tree and calls constructSTUtil()
to fill the allocated memory
*/
static int[] constructST(int arr[], int n)
{
// Allocate memory for segment tree
// Height of segment tree
int x = (int) Math.ceil(Math.log(n) / Math.log(2));
// Maximum size of segment tree
int max_size = 2 * (int) Math.pow(2, x) - 1;
// Allocate memory
int[] tree = new int[max_size];
// Fill the allocated memory st
constructSTUtil(arr, 0, n - 1, tree, 0);
// Return the constructed segment tree
return tree;
}
/*
* Function to construct lazy array
for segment tree. This function allocates
* memory for lazy array
*/
static int[] constructLazy(int arr[], int n)
{
// Allocate memory for lazy array
// Height of lazy array
int x = (int) Math.ceil(Math.log(n) / Math.log(2));
// Maximum size of lazy array
int max_size = 2 * (int) Math.pow(2, x) - 1;
// Allocate memory
int[] lazy = new int[max_size];
// Return the lazy array
return lazy;
}
// Driver Code
public static void main(String[] args)
{
// Initialize the array to zero
// since all pieces are white
int[] arr = {0, 0, 0, 0};
int n = arr.length;
// Build segment tree from given array
int[] tree = constructST(arr, n);
// Allocate memory for Lazy array
int[] lazy = constructLazy(arr, n);
// Print number of black pieces
// from index 0 to 3
System.out.println("Black Pieces in given range = " +
getSum(tree, lazy, n, 0, 3));
// UpdateRange: Change color of pieces
// from index 1 to 2
updateRange(tree, lazy, n, 1, 2);
// Print number of black pieces
// from index 0 to 1
System.out.println("Black Pieces in given range = " +
getSum(tree, lazy, n, 0, 1));
// UpdateRange: Change color of
// pieces from index 0 to 3
updateRange(tree, lazy, n, 0, 3);
// Print number of black pieces
// from index 0 to 3
System.out.println("Black Pieces in given range = " +
getSum(tree, lazy, n, 0, 3));
}
}
// This code is contributed by
// sanjeev2552输出：
Black Pieces in given range = 0
Black Pieces in given range = 1
Black Pieces in given range = 2
时间复杂度：每个查询和每个更新将花费O(Log(N))时间，其中N是棋盘的棋子数。因此，对于Q查询，最坏情况下的复杂度为(Q * Log(N))