public void EmptyTest()
{
var ft = new FenwickTree(0);
Assert.That(ft.Sum(0), Is.Zero);
Assert.That(ft.Sum(0, 0), Is.Zero);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var A = Scanner.ScanEnumerable <int>().Select(x => x - 1).ToArray();
const int mod = (int)1e9 + 7;
var fact = new long[N + 1];
fact[0] = fact[1] = 1;
for (var i = 2; i <= N; i++)
{
fact[i] = fact[i - 1] * i % mod;
}
var answer = 1L;
var ft = new FenwickTree(N);
for (var i = 0; i < N; i++)
{
ft.Add(i, 1);
}
for (var i = 0; i < N; i++)
{
ft.Add(A[i], -1);
answer += ft.Sum(A[i]) * fact[N - i - 1] % mod;
answer %= mod;
}
Console.WriteLine(answer);
}
public void TestSetValue(int index, int valueToSet, int from, int to, int expectedSum)
{
var fenwickTree = new FenwickTree(new[] { 3, 4, -2, 7, 4, 11, 5, -8 });
fenwickTree.SetValue(index, valueToSet);
Assert.That(fenwickTree.GetSum(from, to), Is.EqualTo(expectedSum));
}
public void GivenRandomSumFenwickTreeWhenUpdateValuesThenIntervalReturnsCorrectValues()
{
var rand = new Random();
var arr = new uint[64];
for (int i = 0; i < arr.Length; i++)
{
arr[i] = (uint)rand.Next();
}
var tree = new FenwickTree <uint>(arr, (a, b) => a + b, (a, b) => a - b);
uint sum = 0;
for (int i = 0; i < arr.Length; i++)
{
var elem = (uint)rand.Next();
arr[i] = elem;
tree[i] = elem;
}
for (int i = 0; i < arr.Length; i++)
{
sum += arr[i];
Assert.Equal(sum, tree.GetOperationValueOnInterval(i));
}
}
static void Main(string[] args)
{
var bid = new FenwickTree();
var answer = 0L;
while (true)
{
var currentAction = Console.ReadLine().Split(' ');
if (currentAction.Length == 1)
{
break;
}
var name = currentAction[0];
var value = double.Parse(currentAction[1], CultureInfo.InvariantCulture);
var start = 1000001 - (int)(value * 100.0 + 0.1);
if (name == "BID")
{
bid.Add(start, 1);
}
if (name == "DEL")
{
bid.Add(start, -1);
}
if (name == "SALE")
{
var count = int.Parse(currentAction[2]);
answer += Math.Max(0, Math.Min(count, bid.Sum(start)));
}
}
System.Threading.Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
Console.WriteLine(answer / 100.0);
}
public void GivenArrayWhenConstructFenwickTreeThenNoExceptions()
{
var tree = new FenwickTree <int>(new[] { 1, 2, 3, 4 }, Plus, Minus);
Assert.NotNull(tree);
Assert.Equal(4, tree.Count);
}
static void FenwickTreeTest()
{
long[] ar = { 0 /*Dummy value*/, 1, 2, 3, 4, 5, 6 };
//first entry is not used and can be any value
FenwickTree ft = new FenwickTree(ar);
// Range queries should start at an index of 1
Console.WriteLine(ft.sum(1, 6));
Console.WriteLine(ft.sum(1, 5));
Console.WriteLine(ft.sum(1, 4));
Console.WriteLine(ft.sum(1, 3));
Console.WriteLine(ft.sum(1, 2));
Console.WriteLine(ft.sum(1, 1));
try
{
Console.WriteLine(ft.sum(1, 0)); // <-- invalid bounds!
}
catch (Exception e) { Console.WriteLine(e.ToString()); }
Console.WriteLine(ft.sum(3, 5));
Console.WriteLine(ft.sum(2, 6));
Console.WriteLine(ft.sum(4, 4));
Console.WriteLine();
Console.WriteLine();
Console.WriteLine();
ft.print();
}
public static void Solve()
{
var NQ = Console.ReadLine().Split(" ").Select(int.Parse).ToArray();
var(N, Q) = (NQ[0], NQ[1]);
var A = Console.ReadLine().Split(" ").Select(int.Parse).ToArray();
var ft = new FenwickTree(N);
for (var i = 0; i < N; i++)
{
ft.Add(i, A[i]);
}
for (var i = 0; i < Q; i++)
{
var TPX = Console.ReadLine().Split(" ").Select(int.Parse).ToArray();
var(t, p, x) = (TPX[0], TPX[1], TPX[2]);
if (t == 0)
{
ft.Add(p, x);
}
else
{
Console.WriteLine(ft.Sum(p, x));
}
}
}
public void Run()
{
string[] tokens = Console.ReadLine().Split();
int n = int.Parse(tokens[0]);
int m = int.Parse(tokens[1]);
int k = int.Parse(tokens[2]);
tokens = Console.ReadLine().Split();
FenwickTree result = new FenwickTree(n);
// add initial values
// nums = new int[n];
for (int i = 0; i < n; i++)
{
// nums[i] = int.Parse(tokens[i]);
int v = int.Parse(tokens[i]);
result.Add(i + 1, v); // BIT 1 based index
result.Add(i + 2, -v);
}
// result.PrintArray();
Operation[] ops = new Operation[m];
for (int i = 0; i < m; i++)
{
tokens = Console.ReadLine().Split();
if (tokens.Length != 3)
{
throw new ArgumentException();
}
ops[i] = new Operation(int.Parse(tokens[0]), int.Parse(tokens[1]), int.Parse(tokens[2]));
}
FenwickTree opCount = new FenwickTree(m);
for (int i = 0; i < k; i++)
{
tokens = Console.ReadLine().Split();
int l = int.Parse(tokens[0]);
int r = int.Parse(tokens[1]);
// do for whole tree
opCount.Add(l, 1);
// undo for r to n
opCount.Add(r + 1, -1);
}
// at this point, opCount contains info which operation should be applied
// how many times
// for each operation apply them opCount times
for (int i = 0; i < m; i++)
{
long v = ops[i].d * opCount.Sum(i + 1);
result.Add(ops[i].l, v);
result.Add(ops[i].r + 1, -v);
}
// result.PrintArray();
result.ShowResult();
}
public string run()
{
var testArray = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var tree = new FenwickTree <int>(testArray, Operations.BinPlusInt, Operations.BinMinusInt, 0);
DotSerializer.Show(tree);
return(String.Empty);
}
public void GivenSumFenwickTreeWhenUpdateChangeValueThenIntervalUpdated()
{
var tree = new FenwickTree <int>(Enumerable.Range(1, 5), Plus, Minus);
tree[0] = 10;
Assert.Equal(24, tree.GetOperationValueOnInterval(4));
tree[4] = 10;
Assert.Equal(29, tree.GetOperationValueOnInterval(4));
}
public void GivenFenwickTreeWhenSetOrGetThroughIndexerOutsideOfArrayThenThrowException()
{
var tree = new FenwickTree <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 void GivenSumFenwickTreeWhenAskOperationOnIntervalThenReturnCorrectValues()
{
var tree = new FenwickTree <int>(Enumerable.Range(1, 100), Plus, Minus);
Assert.Equal(1, tree.GetOperationValueOnInterval(0));
for (int i = 1; i < tree.Count; i++)
{
Assert.Equal((i + 2) * (i + 1) / 2, tree.GetOperationValueOnInterval(i));
}
}
public void FenwickTree_GetSumOnTree_ReturnCorrectSum()
{
var expected = 16;
var massive = new int[] { 1, 3, 5, 7, 9, 11 };
var tree = new FenwickTree <int>(massive, new Func <int, int, int>((x, y) => x + y));
var result = tree.GetPrefixSum(3);
result.Should().Be(expected);
}
public void BoundTest()
{
var ft = new FenwickTree(10);
ft.Add(3, long.MaxValue);
ft.Add(5, long.MinValue);
Assert.That(ft.Sum(0, 10), Is.EqualTo(-1));
Assert.That(ft.Sum(0, 10), Is.EqualTo(-1));
Assert.That(ft.Sum(3, 4), Is.EqualTo(long.MaxValue));
Assert.That(ft.Sum(4, 10), Is.EqualTo(long.MinValue));
}
public void GivenSumFenwickTreeWithSelectorWhenCreateTreeThenNoException()
{
var tree = new FenwickTree <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(1));
}
int[] get(int[] a, long inv)
{
var n = a.Length;
var pos = new int[n];
for (int i = 0; i < n; i++)
{
pos[a[i]] = i;
}
var fenwick = new FenwickTree(n);
for (int i = 1; i <= n; i++)
{
fenwick.Add(i, 1);
}
var ret = new int[n];
var ptr = n - 1;
var used = new bool[n];
for (int i = n - 1; i >= 0; i--)
{
var p = pos[i];
fenwick.Add(p + 1, -1);
var v = fenwick[p + 1, n];
if (inv >= v)
{
inv -= v;
used[p] = true;
ret[ptr--] = i;
}
else
{
break;
}
}
ptr = 0;
for (int i = 0; i < n; i++)
{
if (used[i])
{
continue;
}
ret[ptr++] = a[i];
}
for (int i = 0; i + 1 < n && inv > 0; i++)
{
if (ret[i] > ret[i + 1])
{
Swap(ref ret[i], ref ret[i + 1]); inv--;
}
}
return(ret);
}
public void FenwickTree_Sum_Smoke_Test()
{
var testArray = new int[] { 1, 3, 5, 7, 9, 11 };
//tree with sum operation
var tree = new FenwickTree <int>(testArray,
new Func <int, int, int>((x, y) => x + y));
var sum = tree.GetPrefixSum(3);
Assert.AreEqual(16, sum);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var P = Scanner.ScanEnumerable <long>().ToArray();
var A = new int[N];
for (var i = 0; i < N; i++)
{
A[P[i] - 1] = i + 1;
}
var ft = new FenwickTree(N + 2);
ft.Add(0, 2);
ft.Add(N + 1, 2);
var answer = 0L;
for (var ph = N; ph > 0; ph--)
{
var i = A[ph - 1];
var l = ft.Sum(0, i);
var w = ft.LowerBound(l - 1);
var x = ft.LowerBound(l);
var y = ft.LowerBound(l + 1);
var z = ft.LowerBound(l + 2);
answer += (long)ph * (x - w) * (y - i);
answer += (long)ph * (i - x) * (z - y);
ft.Add(i, 1);
}
// var A = new (int i, long p)[N];
// for (var i = 0; i < N; i++) A[i] = (i + 1, P[i]);
// Array.Sort(A, (x, y) => y.p.CompareTo(x.p));
// var stMin = new SegmentTree<int>(N + 1, Math.Min, N + 1);
// var stMax = new SegmentTree<int>(N + 1, Math.Max, 0);
// var answer = 0L;
// for (var ph = 0; ph < N; ph++)
// {
// var (i, p) = A[ph];
// var x = stMax.Query(0, i);
// var w = stMax.Query(0, Math.Max(0, x));
// stMax.Set(i, i);
// var y = stMin.Query(i + 1, N + 1);
// var z = stMin.Query(Math.Min(y + 1, N + 1), N + 1);
// stMin.Set(i, i);
// answer += p * (x - w) * (y - i);
// answer += p * (i - x) * (z - y);
// }
Console.WriteLine(answer);
}
public static void Solve()
{
var K = Scanner.Scan <int>();
var A = new int[K][];
var count = new int[K][];
for (var i = 0; i < K; i++)
{
_ = Scanner.Scan <int>();
A[i] = Scanner.ScanEnumerable <int>().ToArray();
count[i] = new int[21];
foreach (var a in A[i])
{
count[i][a]++;
}
}
var inv = new long[K];
for (var i = 0; i < K; i++)
{
var ft = new FenwickTree(21);
for (var j = 0; j < A[i].Length; j++)
{
var a = A[i][j];
inv[i] += j - ft.Sum(a + 1);
ft.Add(a, 1);
}
}
_ = Scanner.Scan <int>();
var B = Scanner.ScanEnumerable <int>().ToArray();
var sum = new long[21];
mint answer = 0;
foreach (var b in B.Select(x => x - 1))
{
answer += inv[b];
for (var i = 0; i <= 20; i++)
{
for (var j = 0; j < i; j++)
{
answer += sum[i] * count[b][j];
}
sum[i] += count[b][i];
}
}
Console.WriteLine(answer);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var A = Scanner.ScanEnumerable <int>().Select(x => x - 1).ToArray();
var ft = new FenwickTree(N);
var answer = 0L;
for (var i = 0; i < N; i++)
{
answer += i - ft.Sum(A[i]);
ft.Add(A[i], 1);
}
Console.WriteLine(answer);
}
public MutableRangeSumQuery Build(int[] array)
{
var rangeSum = new int[array.Length];
rangeSum[0] = array[0];
for (int i = 1; i < rangeSum.Length; i++)
{
rangeSum[i] = rangeSum[i - 1] + array[i];
}
_fenwickTreeRoot = ParseIntoFenwickTree(rangeSum, 0, array.Length - 1);
return(this);
}
public IList <int> CountSmaller(params int[] nums)
{
var offset = nums.Max(a => Math.Abs(a));
var size = offset * 2 + 1;
var fenwickTree = new FenwickTree(size, offset);
var result = new int[nums.Length];
for (var i = nums.Length - 1; i >= 0; i--)
{
result[i] = fenwickTree.Query(nums[i]);
fenwickTree.Update(nums[i], 1);
}
return(result);
}
public void Solve()
{
var n = sc.Integer();
var k = sc.Integer();
var p = Enumerate(n, x => sc.Integer());
var q = new int[n];
for (int i = 0; i < n; i++)
{
q[p[i] - 1] = i;
}
var G = Enumerate(n, x => new List <int>());
var bit = new FenwickTree(n);
for (int i = n - 1, j = n - 1; i >= 0; i--)
{
while (j >= 0 && i - j < k)
{
bit.Add(p[j], 1);
j--;
}
var pos = p[i];
var sum = bit[pos];
var next = bit.LowerBound(sum + 1);
if (next <= n)
{
G[i].Add(q[next - 1]);
}
var prev = bit.LowerBound(sum - 1);
if (prev > 0 && prev < pos)
{
G[q[prev - 1]].Add(i);
}
bit.Add(pos, -1);
}
var ord = Graph.TopologicalSort(G, true);
var ans = new int[n];
for (int i = 0; i < n; i++)
{
ans[ord[i]] = i + 1;
}
foreach (var x in ans)
{
IO.Printer.Out.WriteLine(x);
}
}
long getinversion(int[] a)
{
var n = a.Length;
long ret = 0;
var fenwick = new FenwickTree(n);
for (int i = 1; i <= n; i++)
{
fenwick.Add(i, 1);
}
foreach (var x in a)
{
var y = x + 1;
fenwick.Add(y, -1);
ret += fenwick[y];
}
return(ret);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var A = Scanner.ScanEnumerable <int>().Select(x => x - 1).ToArray();
var ft = new FenwickTree(N);
var rev = 0L;
for (var i = 0; i < N; i++)
{
rev += i - ft.Sum(A[i]);
ft.Add(A[i], 1);
}
var answer = (rev - N) % 2 == 0;
Console.WriteLine(answer ? "YES" : "NO");
}
public void Test()
{
var tree = new FenwickTree(10);
tree.
Update(1, 1).
Update(2, 3).
Update(3, 4).
Update(4, 8).
Update(5, 6).
Update(6, 1).
Update(7, 4).
Update(8, 2);
var sum = tree.Sum(2, 4);
Assert.Equal(15, sum);
}
public static void Solve()
{
var(N, Q) = Scanner.Scan <int, int>();
var A = Scanner.ScanEnumerable <int>().ToArray();
var i2 = mint.Inverse(2);
var D0 = new FenwickTree(N);
var D1 = new FenwickTree(N);
var D2 = new FenwickTree(N);
void Add(int i, mint v)
{
D0.Add(i, v * i * i);
D1.Add(i, v * i);
D2.Add(i, v);
}
for (var i = 0; i < N; i++)
{
Add(i, A[i]);
}
while (Q-- > 0)
{
var query = Scanner.ScanEnumerable <int>().ToArray();
if (query[0] == 1)
{
var x = query[1] - 1;
var v = query[2];
Add(x, (mint)v - A[x]);
A[x] = v;
}
else
{
var x = query[1] - 1;
var r = (mint)x;
var answer = D0.Sum(x + 1)
- (D1.Sum(x + 1) * (r * 2 + 3))
+ (D2.Sum(x + 1) * (r + 1) * (r + 2));
answer *= i2;
Console.WriteLine(answer);
}
}
}
private FenwickTree ParseIntoFenwickTree(int[] rangeSum, int start, int end)
{
if (start > end)
{
return(null);
}
var pivot = (start + end) / 2;
var root = new FenwickTree()
{
Range = new Tuple <int, int>(start, end),
Value = RangeSumQuery(rangeSum, start, end),
Left = start == end ? null : ParseIntoFenwickTree(rangeSum, start, pivot),
Right = start == end? null : ParseIntoFenwickTree(rangeSum, pivot + 1, end)
};
return(root);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var A = Scanner.ScanEnumerable <int>().ToArray();
var ft = new FenwickTree(N);
var answer = 0L;
foreach (var a in A)
{
answer += ft.Sum(a, N);
ft.Add(a, 1);
}
foreach (var a in A)
{
Console.WriteLine(answer);
answer += N - 1 - a * 2;
}
}
