public void GivenArrayWhenConstructBinaryIndexedTreeThenNoExceptions()
{
var tree = new BinaryIndexedTree <int>(new[] { 1, 2, 3, 4 }, Plus, Minus);
Assert.NotNull(tree);
Assert.Equal(4, tree.Count);
}
public void Solve()
{
int N = Reader.Int();
int[] X = new int[N], V = new int[N];
for (int i = 0; i < N; i++)
{
X[i] = Reader.Int(); V[i] = Reader.Int();
}
V = Compress(V);
Array.Sort(X, V);
int[] L = new int[N], R = new int[N];
for (int i = 0, max = -1; i < N; i++)
{
R[i] = max = Math.Max(max, V[i] + 1);
}
for (int i = N - 1, min = int.MaxValue; i >= 0; i--)
{
L[i] = min = Math.Min(min, V[i]);
}
var BIT = new BinaryIndexedTree(N + 1, Mod);
BIT.Add(0, 1);
for (int i = 0; i < N; i++)
{
BIT.Add(R[i], BIT.Sum(L[i], R[i] + 1));
}
Console.WriteLine(BIT.Sum(N, N + 1));
}
public static long GetNum(int[] ns)
{
int n = ns.Length;
var sortedNs = new int[n];
for (int j = 0; j < n; j++)
{
sortedNs[j] = ns[j];
}
Array.Sort(sortedNs);
for (int j = 0; j < n; j++)
{
ns[j] = Array.BinarySearch(sortedNs, ns[j]);
}
Array.Reverse(ns);
var bit = new BinaryIndexedTree(n);
long total = 0;
bit.update(ns[0], 1);
for (int j = 1; j < n; j++)
{
total += bit.query(ns[j] - 1);
bit.update(ns[j], 1);
}
return(total);
}
public static ulong Solve(int n, int k, int[][] edges)
{
foreach (var edge in edges)
{
edge[0]++;
edge[1]++;
}
var adj = GraphHelper.ToAdjacencyList(edges, n + 1);
var bit = new BinaryIndexedTree(n);
var notHeads = new bool[n + 1];
notHeads[0] = true;
foreach (var edge in edges)
{
notHeads[edge[1]] = true;
}
var head = notHeads.FirstIndexOf(nh => !nh);
var count = Solve_Bit_Dfs(bit, adj, head, n, k);
return((ulong)count);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var n = inputStream.ReadInt();
var a = inputStream.ReadIntArray();
var candidates = a.Distinct().OrderBy(ai => ai).ToArray();
bool CanBeMedian(int m)
{
var isGreaterEqual = a.Select(ai => ai >= m ? 1 : -1).ToArray();
var prefixSum = new int[isGreaterEqual.Length + 1];
for (int i = 0; i < isGreaterEqual.Length; i++)
{
prefixSum[i + 1] = prefixSum[i] + isGreaterEqual[i];
}
long count = 0;
var bit = new BinaryIndexedTree(2 * n + 1); // bit[n]が0を表すようオフセット
foreach (var ps in prefixSum)
{
var offsetted = ps + n;
count += bit.Sum(..(offsetted + 1));
bit.AddAt(offsetted, 1);
}
return(count >= ((long)n * (n + 1) / 2 + 1) / 2);
}
var index = SearchExtensions.BoundaryBinarySearch(i => CanBeMedian(candidates[i]), 0, candidates.Length);
yield return(candidates[index]);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var(n, k) = inputStream.ReadValue <int, int>();
var a = new int[n];
for (int i = 0; i < n; i++)
{
a[i] = inputStream.ReadInt() - k;
}
var prefixSum = new long[a.Length + 1];
for (int i = 0; i < a.Length; i++)
{
prefixSum[i + 1] = prefixSum[i] + a[i];
}
var shrinker = new CoordinateShrinker <long>(prefixSum); // 座圧
var bit = new BinaryIndexedTree(shrinker.Count);
long count = 0;
foreach (var s in prefixSum)
{
count += bit.Sum(..(shrinker.Shrink(s) + 1)); // 転倒数を数える
bit[shrinker.Shrink(s)]++;
}
yield return(count);
}
public void GivenMinBinaryIndexedTreeWhenUpdateChangeValueThenIntervalUpdated()
{
var data = Enumerable.Range(1, 200).ToArray();
var tree = new BinaryIndexedTree <int>(data,
(a, b) => Math.Min(a, b),
(a, b) =>
{
if (a > b)
{
throw new Exception("Can only decrease value");
}
return(Math.Min(a, b));
},
int.MaxValue
);
for (int i = 0; i < data.Length; i++)
{
int min = int.MaxValue;
for (int j = i; j < data.Length; j++)
{
min = Math.Min(min, data[j]);
Assert.Equal(min, tree.GetOperationValueOnInterval(i, j));
}
}
}
public void GivenRandomSumBinaryIndexedTreeWhenUpdateValuesThenIntervalReturnsCorrectValues()
{
var rand = new Random();
var data = new uint[64];
for (int i = 0; i < data.Length; i++)
{
data[i] = (uint)rand.Next();
}
var tree = new BinaryIndexedTree <uint>(data, (a, b) => a + b, (a, b) => a - b);
for (int i = 0; i < data.Length; i++)
{
var elem = (uint)rand.Next();
data[i] = elem;
tree[i] = elem;
}
for (int i = 0; i < data.Length; i++)
{
uint sum = 0;
for (int j = i; j < data.Length; j++)
{
sum += data[j];
Assert.Equal(sum, tree.GetOperationValueOnInterval(i, j));
}
}
}
public void BITInitializationZeroTest()
{
const int length = 5;
var bit = new BinaryIndexedTree(length);
Assert.Equal(length, bit.Length);
Assert.Equal(0, bit.Sum(length));
}
public static void Main()
{
//var tree = new TreeNode<int>(20,
// new TreeNode<int>(44,
// new TreeNode<int>(17), new TreeNode<int>(41)),
// new TreeNode<int>(02,
// new TreeNode<int>(99), new TreeNode<int>(97)));
// DFS(tree);
// BFS(tree);
//DFSWithStack(tree);
//var array = new int[10];
//var random = new Random();
//for (int i = 0; i < array.Length; i++)
//{
// array[i] = random.Next() % 100;
//}
//Console.WriteLine(string.Join(" ", array));
//var heap = new BinaryHeap.BinaryHeap<int>((a, b) => a > b);
//foreach (var element in array)
//{
// heap.Insert(element);
// Console.Write(heap.GetTop() + " ");
//}
//Console.WriteLine();
//for (int i =0; i < array.Length; i++)
//{
// array[i] = heap.GetTop();
// heap.RemoveTop();
//}
//Console.WriteLine(string.Join(" ", array));
//var array = new int[10];
//var random = new Random();
//for (int i =0; i < array.Length; i++)
//{
// array[i] = random.Next() % 100;
//}
//array.HeapSort((a, b) => a > b);
var list = new List <int>();
list.Add(3);
list.Add(4);
list.Add(5);
var indexedTree = new BinaryIndexedTree <int>(list, (a, b) => a + b);
Console.WriteLine(indexedTree.GetInterval(0, 3));
}
public void GivenBinaryIndexedTreeWhenSetOrGetThroughIndexerOutsideOfArrayThenThrowException()
{
var tree = new BinaryIndexedTree <int>(new[] { 1, 2, 3, 4 }, Plus, Minus);
Assert.Throws <ArgumentOutOfRangeException>(() => tree[-1]);
Assert.Throws <ArgumentOutOfRangeException>(() => tree[4]);
Assert.Throws <ArgumentOutOfRangeException>(() => tree[-1] = 1);
Assert.Throws <ArgumentOutOfRangeException>(() => tree[4] = 1);
}
public static long GetNum(int[] sequenceA, int[] sequenceB)
{
int n = sequenceA.Length;
int size = (int)(2 * 1e5 + 1);
var cnt = new int[size];
for (int i = 0; i < n; i++)
{
cnt[sequenceA[i]]++;
}
var f = new long[size];
var c = new long[size];
f[0] = c[0] = 1;
for (int i = 1; i < size; i++)
{
f[i] = (f[i - 1] * i) % mod;
// Modular multiplicative inverse and Fermat's little theorem
c[i] = ModularExponentiation.ModularOfPow(f[i], mod - 2, mod);
}
long comb = f[n];
for (int i = 1; i < size; ++i)
{
comb = (comb * c[cnt[i]]) % mod;
}
var bitree = new BinaryIndexedTree(size + 1);
for (int i = 1; i < size; ++i)
{
bitree.update(i, cnt[i]);
}
long ans = 0;
for (int i = 1; i <= n; ++i)
{
comb = (comb * ModularExponentiation.ModularOfPow(n - i + 1, mod - 2, mod)) % mod;
ans = (ans + comb * bitree.query(sequenceB[i - 1] - 1)) % mod;
comb = (comb * cnt[sequenceB[i - 1]]) % mod;
--cnt[sequenceB[i - 1]];
if (cnt[sequenceB[i - 1]] < 0)
{
break;
}
bitree.update(sequenceB[i - 1], -1);
}
return(ans);
}
static BinaryIndexedTree ReadString(string a)
{
var bit = new BinaryIndexedTree(a.Length);
for (var i = 0; i < a.Length; ++i)
{
bit.Set(i, (a[i] == 'A') ? 1 : 2);
}
return(bit);
}
public void Test1()
{
var t = new BinaryIndexedTree(4);
t.Update(0, 1);
t.Update(3, 4);
t.Query(0, 3).Should().Be(5);
t.Query(2).Should().Be(1);
t.Query(1, 3).Should().Be(4);
}
public void GetSum_CreateBITAndRequestSum_ReturnCorrect()
{
int[] array = { 2, 1, 1, 3, 2, 3, 4, 5, 6, 7, 8, 9 };
var tree = new BinaryIndexedTree(array);
var expectedSum = 12;
var resultedSum = tree.GetSum(5);
resultedSum.Should().Be(expectedSum);
}
string Solve(int N, int[] who, int[] index)
{
Array.Sort(index, who);
var ans = new int[N * N];
int L = 0;
var bit = new BinaryIndexedTree(N * N);
for (int i = 0; i < N * N; i++)
{
bit.Add(i, 1);
}
for (int i = 0; i < N; i++)
{
if (bit.Sum(index[i]) < who[i])
{
return(No);
}
ans[index[i]] = who[i];
bit.Add(index[i], -1);
int num = who[i] - 1;
for (; L < ans.Length && num > 0; L++)
{
if (ans[L] == 0)
{
num--;
bit.Add(L, -1);
ans[L] = who[i];
}
}
if (num > 0)
{
return(No);
}
}
for (int i = 0; i < N; i++)
{
for (int num = N - who[i]; L < ans.Length && num > 0; L++)
{
if (ans[L] == 0)
{
if (L < index[i])
{
return(No);
}
ans[L] = who[i];
num--;
}
}
}
return(Yes + "\n" + string.Join(" ", ans));
}
public static long Solve_Bit_Dfs(BinaryIndexedTree bit, List <int>[] adj, int node, int n, int k)
{
var count = bit.Get(Math.Max(1, node - k), Math.Min(n, node + k));
bit.SetDiff(node, 1);
foreach (var child in adj[node])
{
count += Solve_Bit_Dfs(bit, adj, child, n, k);
}
bit.SetDiff(node, -1);
return(count);
}
public void BinaryIndexedTreeSuccess()
{
int[] array = new int[] { 1, 3, 5 };
int n = array.Length;
var binaryTree = new BinaryIndexedTree(array);
var result = binaryTree.RangeQuery(0, n - 1);
Assert.AreEqual(result, 9);
}
public void GivenBinaryIndexedTreeWithSelectorWhenCreateTreeThenNoException()
{
var tree = new BinaryIndexedTree <Stub, int>(new[] { new Stub()
{
A = 1, B = 1
}, new Stub()
{
A = 100, B = 2
} }, Plus, Minus, (x) => x.B);
Assert.Equal(3, tree.GetOperationValueOnInterval(0, 1));
}
public void TestMethod1()
{
int[] A = { 2, 1, 1, 3, 2, 3, 4, 5, 6, 7, 8, 9 };
BinaryIndexedTree biTree = new BinaryIndexedTree(A);
var sum = biTree.GetSum(5);
Assert.AreEqual(12, sum);
biTree.Add(3, 6);
sum = biTree.GetSum(5);
Assert.AreEqual(18, sum);
}
// Works only with comutative operation ( ex: *, + )
public static void Main()
{
var binaryIndexedTree = new BinaryIndexedTree <int>(30, (a, b) => { return(a * b); });
for (int i = 0; i < 10; i++)
{
binaryIndexedTree[i] = i;
}
Console.WriteLine(binaryIndexedTree.GetInterval(0, 5));
Console.WriteLine(binaryIndexedTree.GetInterval(6, 10));
Console.WriteLine(binaryIndexedTree.GetInterval(3, 7));
}
public void UpdateTree_UpdateTreeAndRequestSum_GetSum()
{
int[] array = { 2, 1, 1, 3, 2, 3, 4, 5, 6, 7, 8, 9 };
var tree = new BinaryIndexedTree(array);
var expectedSum = 18;
array[3] += 6;
tree.UpdateTree(3, 6);
var resultedSum = tree.GetSum(5);
resultedSum.Should().Be(expectedSum);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var(sitesCount, queriesCount) = inputStream.ReadValue <int, int>();
var yCoordinates = new HashSet <int>();
var queries = new List <Query>();
var toAnswer = new Queue <SumQuery>();
var answers = new Dictionary <SumQuery, long>();
for (int i = 0; i < sitesCount; i++)
{
var(x, y, d, c) = inputStream.ReadValue <int, int, int, int>();
yCoordinates.Add(y);
yCoordinates.Add(y + d + 1);
queries.Add(new AddQuery(x, y, d, c));
queries.Add(new AddQuery(x + d + 1, y, d, -c));
}
for (int i = 0; i < queriesCount; i++)
{
var(a, b) = inputStream.ReadValue <int, int>();
yCoordinates.Add(b);
var query = new SumQuery(a, b);
queries.Add(query);
toAnswer.Enqueue(query);
}
queries.Sort();
var shrinker = new CoordinateShrinker <int>(yCoordinates);
var costs = new BinaryIndexedTree(shrinker.Count);
foreach (var query in queries)
{
var shrinkedY = shrinker.Shrink(query.Y);
if (query is AddQuery addQuery)
{
var shrinkedYPlusD = shrinker.Shrink(addQuery.Y + addQuery.Distance + 1);
costs.AddAt(shrinkedY, addQuery.Cost);
costs.AddAt(shrinkedYPlusD, -addQuery.Cost);
}
else if (query is SumQuery sumQuery)
{
answers.Add(sumQuery, costs.Sum(shrinkedY + 1));
}
}
foreach (var query in toAnswer)
{
yield return(answers[query]);
}
}
public void BITSumFromZeroTest()
{
var a = new long[] { 5, 3, 7, 9, 8 };
long[] sum = GetPrefixSum(a);
var bit = new BinaryIndexedTree(a);
Assert.Equal(a.Length, bit.Length);
for (int i = 0; i < sum.Length; i++)
{
Assert.Equal(sum[i], bit.Sum(i));
}
}
// Main function
public static void Main(string[] args)
{
int[] freq = new int[] { 2, 1, 1, 3, 2, 3, 4, 5, 6, 7, 8, 9 };
int n = freq.Length;
BinaryIndexedTree tree = new BinaryIndexedTree();
// Build fenwick tree from given array
tree.constructBITree(freq, n);
Console.WriteLine("Sum of elements in arr[0..5]" + " is = " + tree.getSum(5));
freq[3] += 6;
updateBIT(n, 3, 6);
// Find sum after the value is updated
Console.WriteLine("Sum of elements in arr[0..5]" + " after update is = " + tree.getSum(5));
}
public void GivenSumBinaryIndexedTreeWhenAskOperationOnIntervalThenReturnCorrectValues()
{
var data = Enumerable.Range(1, 200).ToArray();
var tree = new BinaryIndexedTree <int, int>(data, (a, b) => a + b, (a, b) => a - b, (x) => x);
for (int i = 0; i < data.Length; i++)
{
int sum = 0;
for (int j = i; j < data.Length; j++)
{
sum += data[j];
Assert.Equal(sum, tree.GetOperationValueOnInterval(i, j));
}
}
}
long Check(int n, int[][] ab, BitSet flip)
{
if (flip.Count() % 2 != 0)
{
return(-1);
}
var odds = new List <int>();
var evens = new List <int>();
for (int i = 0; i < n; i++)
{
if (flip[i] ^ ((i & 1) == 1))
{
evens.Add(ab[flip[i] ? 1 : 0][i]);
}
else
{
odds.Add(ab[flip[i] ? 1 : 0][i]);
}
}
odds.Sort();
evens.Sort();
var current = odds[0];
for (int i = 1; i < n; i++)
{
int next = i % 2 == 0 ? odds[i >> 1] : evens[i >> 1];
if (current > next)
{
return(-1);
}
}
long count = 0;
var bit = new BinaryIndexedTree(51);
for (int i = 0; i < n; i++)
{
var next = ab[flip[i] ? 1 : 0][i];
count += bit.Sum((next + 1)..);
bit[next]++;
}
return(count);
}
public void BITSumFromAnyTest()
{
var a = new long[] { 5, 3, 7, 9, 8 };
var sum = GetPrefixSum(a);
var bit = new BinaryIndexedTree(a);
Assert.Equal(a.Length, bit.Length);
for (int begin = 0; begin < bit.Length; begin++)
{
for (int end = begin; end <= bit.Length; end++)
{
Assert.Equal(sum[end] - sum[begin], bit.Sum(begin, end));
}
}
}
public void GivenSumBinaryIndexedTreeWhenUpdateChangeValueThenIntervalUpdated()
{
var data = Enumerable.Range(1, 200).ToArray();
var tree = new BinaryIndexedTree <int, int>(data, (a, b) => a + b, (a, b) => a - b, (x) => x);
data[10] = 100;
tree[10] = 100;
for (int i = 0; i < data.Length; i++)
{
int sum = 0;
for (int j = i; j < data.Length; j++)
{
sum += data[j];
Assert.Equal(sum, tree.GetOperationValueOnInterval(i, j));
}
}
}
public static BinaryIndexedTree FromArray(int[] input)
{
if (input is null)
{
return(null);
}
var result = new BinaryIndexedTree(input.Length + 1);
var index = 0;
foreach (var item in input)
{
result.SetValue(index, item);
index++;
}
return(result);
}
public long countColoring(int n, int xzero, int xmul, int xadd, int xmod, int yzero, int ymul, int yadd, int ymod)
{
int[] xs = new int[n], ys = new int[n];
Point[] points = new Point[n];
xs[0] = xzero;
ys[0] = yzero;
points[0] = new Point(xs[0], ys[0]);
for (int i = 1; i < n; ++i) {
xs[i] = (int)(((long)points[i - 1].X * xmul + xadd) % xmod);
ys[i] = (int)(((long)points[i - 1].Y * ymul + yadd) % ymod);
points[i] = new Point(xs[i], ys[i]);
}
Array.Sort(xs);
Array.Sort(ys);
for (int i = 0; i < n; ++i) {
points[i].X = Array.BinarySearch(xs, points[i].X) + 1;
points[i].Y = Array.BinarySearch(ys, points[i].Y) + 1;
}
Array.Sort(points);
long count = 0;
BinaryIndexedTree tree;
tree = new BinaryIndexedTree(n);
int[] countL = new int[n], countR = new int[n];
for (int i = 0; i < n; ++i) {
countL[i] = tree.Sum(points[i].Y);
tree.Add(points[i].Y, 1);
}
tree = new BinaryIndexedTree(n);
for (int i = n - 1; i >= 0; --i) {
countR[i] = tree.Sum(n) - tree.Sum(points[i].Y);
count += (long)countR[i] * (countR[i] - 1) / 2;
count -= (long)countL[i] * countR[i];
tree.Add(points[i].Y, 1);
}
return count;
}
