public void TestAddSegmentTree2()
{
// Arrange
var st = new SegmentTree(5);
// Act
st.Set(4, 0);
st.Set(3, 1);
st.Set(2, 2);
st.Set(1, 1);
st.Set(0, 2);
// Assert
Assert.AreEqual(0, st._data[6]);
Assert.AreEqual(1, st._data[5]);
Assert.AreEqual(2, st._data[4]);
Assert.AreEqual(1, st._data[8]);
Assert.AreEqual(2, st._data[7]);
Assert.AreEqual(0, st._data[2]);
Assert.AreEqual(1, st._data[3]);
Assert.AreEqual(1, st._data[1]);
Assert.AreEqual(0, st._data[0]);
}
public static void Main()
{
var nm = Console.ReadLine().Split().Select(int.Parse).ToArray();
var n = nm[0];
var m = nm[1];
var constraints = Enumerable.Repeat(0, m).Select(_ => Console.ReadLine().Split().Select(int.Parse).ToArray()).Select(x => (l: x[0] - 1, r: x[1] - 1, x: x[2])).ToArray();
int[] res = new int[n];
SegmentTree <int> segTree = new SegmentTree <int>(n, 0, (x, y) => x + y);
PriorityQueue <int> pqueue = new PriorityQueue <int>(true);
int nextUpdate = 0;
foreach (var(l, r, x) in constraints.OrderBy(x => x.r))
{
while (nextUpdate <= r)
{
pqueue.Push(nextUpdate);
nextUpdate++;
}
var curSum = segTree.Query(l, r);
while (curSum < x)
{
var pos = pqueue.Pop();
res[pos]++;
segTree[pos]++;
curSum++;
}
}
Console.WriteLine(string.Join(" ", res));
}
public IList <int> CountSmaller(int[] nums)
{
int[] result = new int[nums.Length];
SortedDictionary <int, List <int> > dict = new SortedDictionary <int, List <int> >();
for (int i = 0; i < nums.Length; i++)
{
List <int> l;
if (!dict.TryGetValue(nums[i], out l))
{
dict.Add(nums[i], l = new List <int>());
}
l.Add(i);
}
SegmentTree tree = new SegmentTree(0, nums.Length - 1);
foreach (var pair in dict)
{
foreach (int pos in pair.Value)
{
result[pos] = tree.CountRange(pos + 1, nums.Length - 1);
}
foreach (int pos in pair.Value)
{
tree.Add(pos);
}
}
return(result.ToList());
}
static void Main()
{
var nk = Console.ReadLine().Split().Select(int.Parse).ToArray();
var n = nk[0];
var k = nk[1];
long[] accums = new long[n + 1];
for (int i = 1; i < accums.Length; i++)
{
accums[i] = accums[i - 1] + int.Parse(Console.ReadLine()) - k;
}
var list = accums.Distinct().ToList();
list.Sort();
SegmentTree <int> segTree = new SegmentTree <int>(list.Count, 0, (x, y) => x + y);
long res = 0;
for (int i = 0; i < accums.Length; i++)
{
var ind = list.BinarySearch(accums[i]);
res += segTree.Query(0, ind);
segTree.Operate(ind, 1);
}
Console.WriteLine(res);
}
private void VerifySmall(int empty, Func <int, int, int> append)
{
const int Min = -100;
const int Max = 100;
var random = new Random();
for (var count = 1; count < 15; count++)
{
var array = Enumerable.Repeat(0, count).Select(_ => random.Next(Min, Max)).ToArray();
var tree = SegmentTree.Create(array, empty, append);
tree.Count.Is(count);
tree.IsSeq(array);
Verify(array, tree);
for (var s = 0; s < 20; s++)
{
var i = random.Next(0, count);
var item = random.Next(Min, Max);
tree[i] = item;
array[i] = item;
Verify(array, tree);
}
}
}
public void Test_FromSemigroup()
{
var tree = SegmentTree.FromSemigroup(new[] { 3, 1, 4, 2, 5 }, (x, y) => x + y);
tree.Query(1, 3).value.Is(7);
tree.Query(5, 0).ok.Is(false);
}
static void Method(string[] args)
{
int[] nq = ReadInts();
int n = nq[0];
int q = nq[1];
int[] array = ReadInts();
var tree = new SegmentTree <int>(n, (a, b) => a ^ b, 0, 0);
for (int i = 0; i < n; i++)
{
tree.Update(i, array[i]);
}
for (int i = 0; i < q; i++)
{
int[] txy = ReadInts();
int t = txy[0];
int x = txy[1];
int y = txy[2];
if (t == 1)
{
int now = tree.Look(x - 1);
tree.Update(x - 1, now ^ y);
}
else
{
WriteLine(tree.Scan(x - 1, y - 1));
}
}
}
public static long Solve(long[] a)
{
var seq1 = new List <long>();
for (int i = 0; i < a.Length - 1; i++)
{
seq1.Add(Abs(a[i + 1] - a[i]) * (i % 2 == 0 ? 1 : -1));
}
var accum = new List <long>()
{
0
};
foreach (var item in seq1)
{
accum.Add(accum.Last() + item);
}
SegmentTree <long> segTree = new SegmentTree <long>(accum.ToArray(), long.MinValue / 2, Max);
var res = long.MinValue;
for (int i = 0; i < segTree.Size; i += 2)
{
res = Max(res, segTree.Query(i + 1, segTree.Size - 1) - segTree[i]);
}
return(res);
}
public static void Main()
{
var nk = Console.ReadLine().Split().Select(int.Parse).ToArray();
var n = nk[0];
var k = nk[1];
var a = Console.ReadLine().Split().Select(int.Parse).ToArray();
//var a = Enumerable.Repeat(0, n).ToArray();
//nが小さい時注意
for (int count = 0; count < k; count++)
{
SegmentTree <int> next = new SegmentTree <int>(n, 0, (x, y) => x + y);
for (int i = 0; i < n; i++)
{
next.Operate(Max(i - a[i], 0), Min(i + a[i], n - 1), 1);
}
var isAllN = true;
for (int i = 0; i < n; i++)
{
a[i] = next[i];
if (a[i] != n)
{
isAllN = false;
}
}
if (isAllN)
{
break;
}
//Console.WriteLine(string.Join(" ", a));
}
Console.WriteLine(string.Join(" ", a));
}
static void SegmentTreeTest()
{
int[] A = { 8, 7, 3, 9, 5, 1, 10 };
SegmentTree <int> t = new SegmentTree <int>(A.Length);
t.buildTree(A);
Console.WriteLine("{0} ", t.get(0, 1));
Console.WriteLine("{0} ", t.get(1, 1));
Console.WriteLine("{0} ", t.get(1, 2));
Console.WriteLine("{0} ", t.get(1, 3));
Console.WriteLine("{0} ", t.get(0, 3));
Console.WriteLine("{0} ", t.get(3, 3));
Console.WriteLine();
t.set(11, 2, 2);
Console.WriteLine("{0} ", t.get(0, 1));
Console.WriteLine("{0} ", t.get(1, 1));
Console.WriteLine("{0} ", t.get(1, 2));
Console.WriteLine("{0} ", t.get(1, 3));
Console.WriteLine("{0} ", t.get(0, 3));
Console.WriteLine("{0} ", t.get(3, 3));
Console.WriteLine();
t.set(33, 1, 2);
Console.WriteLine("{0} ", t.get(0, 1));
Console.WriteLine("{0} ", t.get(1, 1));
Console.WriteLine("{0} ", t.get(1, 2));
Console.WriteLine("{0} ", t.get(1, 3));
Console.WriteLine("{0} ", t.get(0, 3));
Console.WriteLine("{0} ", t.get(3, 3));
Console.WriteLine();
}
private static void Main(string[] args)
{
var input = File.ReadAllLines(InputFileName);
var size = int.Parse(input[0]);
var tree = new SegmentTree(500000 + 1);
var ranks = new int[size];
foreach (var line in input.Skip(1))
{
var coords = line.Split().Select(int.Parse).ToArray();
var(x, y) = (coords[0], coords[1]);
var rank = tree.SumRange(0, x + 1);
ranks[rank]++;
var count = tree.Get(x);
tree.Update(x, count + 1);
}
var output = string.Join("\n", ranks);
File.WriteAllText(OutputFileName, output);
}
public static void Main()
{
var nm = Console.ReadLine().Split().Select(int.Parse).ToArray();
var n = nm[0];
var m = nm[1];
var a = Console.ReadLine().Split().Select(int.Parse).ToArray();
SegmentTree <int> segTree = new SegmentTree <int>(Enumerable.Range(0, n + 1).ToArray(), int.MaxValue, Min);
int[] cnt = new int[n];
for (int i = 0; i < m; i++)
{
cnt[a[i]]++;
segTree[a[i]] = int.MaxValue;
}
var res = int.MaxValue;
for (int i = 0; i <= n - m; i++)
{
res = Min(res, segTree.Query(0, n));
cnt[a[i]]--;
if (cnt[a[i]] == 0)
{
segTree[a[i]] = a[i];
}
if (i == n - m)
{
break;
}
cnt[a[i + m]]++;
segTree[a[i + m]] = int.MaxValue;
}
Console.WriteLine(res);
}
public static void Main()
{
var nm = Console.ReadLine().Split().Select(long.Parse).ToArray();
var m = nm[1];
var queries = Enumerable.Repeat(0, (int)m).Select(_ => Query.Parse(Console.ReadLine())).ToArray();
var compressDict = queries.Select(x => x.N).Distinct().OrderBy(x => x).Select((Elem, Index) => new { Elem, Index }).ToDictionary(x => x.Elem, x => x.Index);
SegmentTree <Linear> segTree = new SegmentTree <Linear>(compressDict.Count, new Linear()
{
A = 1, B = 0
}, Linear.Merge);
double min = 1;
double max = 1;
foreach (var query in queries)
{
segTree[compressDict[query.N]] = new Linear()
{
A = query.A, B = query.B
};
var res = segTree.Query(0, compressDict.Count - 1);
max = Max(max, res.A + res.B);
min = Min(min, res.A + res.B);
}
Console.WriteLine(min);
Console.WriteLine(max);
}
static bool Solve(int maxA, int maxB, Section[] a, Section[] b)
{
List <int>[] events = Enumerable.Range(0, maxA + 1).Select(_ => new List <int>()).ToArray();
for (int i = 0; i < a.Length; i++)
{
events[a[i].Begin].Add(i + 1);
events[a[i].End + 1].Add(-(i + 1));
}
SegmentTree <int, int> segTree = new SegmentTree <int, int>(maxB, 0, 0, Max, (x, y) => x + y, (x, y) => x + y);
int count = 0;
for (int i = 0; i < events.Length; i++)
{
foreach (var @event in events[i])
{
var target = Abs(@event) - 1;
var sign = Sign(@event);
var bElem = b[target];
count += sign;
segTree.Update(bElem.Begin, bElem.End, sign);
}
var queryRes = segTree.Query(0, maxB - 1);
if (queryRes != count)
{
return(false);
}
}
return(true);
}
public static void Main()
{
var nq = Console.ReadLine().Split().Select(int.Parse).ToArray();
var a = Console.ReadLine().Split().Select(int.Parse).ToArray();
//クエリ先読み昇順ソート
SegmentTree <long> rsq = new SegmentTree <long>(nq[0], 0, (x, y) => x + y);
SegmentTree <long> rcq = new SegmentTree <long>(nq[0], 0, (x, y) => x + y);
Stack <int> stack = new Stack <int>(a.Select((Elem, Index) => new { Elem, Index }).OrderBy(x => x.Elem).Select(x => x.Index));
long[] res = new long[nq[1]];
//大きいクエリから降ってくるので、できるところから追加
foreach (var item in Enumerable.Range(0, nq[1]).Select(Index => new { Index, Elem = Console.ReadLine().Split().Select(int.Parse).ToArray() }).OrderByDescending(x => x.Elem[3]))
{
var l = item.Elem[1] - 1;
var r = item.Elem[2] - 1;
var x = item.Elem[3];
while (stack.Count != 0 && x <= a[stack.Peek()])
{
var ind = stack.Pop();
rsq[ind] = a[ind];
rcq[ind] = 1;
}
res[item.Index] = rsq.Query(l, r) - rcq.Query(l, r) * x;
}
Console.WriteLine(string.Join("\n", res));
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var n = inputStream.ReadInt();
var a = inputStream.ReadLongArray();
var segmentTree = new SegmentTree <long?>(a.Cast <long?>().ToArray(), (x, y) =>
{
if (x == null)
{
return(y);
}
else if (y == null)
{
return(x);
}
else
{
return(Gcd(x.Value, y.Value));
}
}, null);
var maxGcd = segmentTree.Query(1, segmentTree.Length).Value;
for (int i = 1; i < segmentTree.Length - 1; i++)
{
maxGcd = Math.Max(maxGcd, Gcd(segmentTree.Query(0, i).Value, segmentTree.Query(i + 1, segmentTree.Length).Value));
}
maxGcd = Math.Max(maxGcd, segmentTree.Query(0, segmentTree.Length - 1).Value);
yield return(maxGcd);
}
static void Main()
{
var nm = Console.ReadLine().Split().Select(int.Parse).ToArray();
int n = nm[0];
int m = nm[1];
SegmentTree <int> segTree = new SegmentTree <int>(m + 1, 0, (x, y) => x + y);
int sectionIndex = 0;
int[][] sections = Enumerable.Repeat(0, n).Select(_ => Console.ReadLine().Split().Select(int.Parse).ToArray()).OrderBy(x => x[1] - x[0]).ToArray();
int[] resArr = new int[m];
for (int i = 1; i <= m; i++)
{
var res = 0;
//???i????????????(??????????????)
while (sectionIndex < sections.Length && sections[sectionIndex][1] - sections[sectionIndex][0] + 1 < i)
{
segTree.Operate(sections[sectionIndex][0], sections[sectionIndex][1] + 1, 1);
sectionIndex++;
}
//??????????(????i?????????????sectionIndex?????????)
res += nm[0] - sectionIndex;
for (int j = 0; j <= m; j += i)
{
var query = segTree.Query(j);
res += query;
}
resArr[i - 1] = res;
}
Console.WriteLine(string.Join("\n", resArr));
}
public IList<int> CountSmaller(int[] nums)
{
int[] result = new int[nums.Length];
SortedDictionary<int, List<int>> dict = new SortedDictionary<int, List<int>>();
for (int i = 0; i < nums.Length; i++)
{
List<int> l;
if (!dict.TryGetValue(nums[i], out l))
{
dict.Add(nums[i], l = new List<int>());
}
l.Add(i);
}
SegmentTree tree = new SegmentTree(0, nums.Length - 1);
foreach (var pair in dict)
{
foreach (int pos in pair.Value)
{
result[pos] = tree.CountRange(pos + 1, nums.Length - 1);
}
foreach (int pos in pair.Value)
{
tree.Add(pos);
}
}
return result.ToList();
}
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(x => new S(int.Parse(x))).ToArray();
var st = new SegmentTree <S>(A, new Oracle());
for (var i = 0; i < Q; i++)
{
var TXY = Console.ReadLine().Split(" ").Select(int.Parse).ToArray();
var(T, X, V) = (TXY[0], TXY[1], TXY[2]);
X--;
switch (T)
{
case 1:
st.Set(X, new S(V));
break;
case 2:
Console.WriteLine(st.Query(X, V).Value);
break;
case 3:
Console.WriteLine(st.MaxRight(X, v => v.Value < V) + 1);
break;
}
}
}
public static void Main()
{
var nd = Console.ReadLine().Split().Select(int.Parse).ToArray();
var n = nd[0];
var d = nd[1];
var walls = Enumerable.Repeat(0, n).Select(_ => Console.ReadLine().Split().Select(int.Parse).ToArray()).ToArray();
var arr = walls.SelectMany(x => x).Concat(walls.Select(x => x[1] + d - 1)).Distinct().OrderBy(x => x).ToArray();
var dic = arr.Select((elem, ind) => (elem, ind)).ToDictionary(x => x.elem, x => x.ind);
var segTree = new SegmentTree <bool, bool>(dic.Count, false, false, (x, y) => x | y, (x, y) => x | y, (x, y) => x | y);
int res = 0;
foreach (var wall in walls.OrderBy(x => x[1]))
{
var l = wall[0];
var r = wall[1];
if (segTree.Query(dic[l], dic[r]))
{
continue;
}
segTree.Update(dic[r], dic[r + d - 1], true);
res++;
}
Console.WriteLine(res);
}
public static void Main()
{
var nq = Console.ReadLine().Split().Select(int.Parse).ToArray();
var n = nq[0];
var q = nq[1];
var a = Console.ReadLine().Split().Select(int.Parse).Prepend(0).ToArray();
SegmentTree <int> seg = new SegmentTree <int>(a, 0, (x, y) => x ^ y);
for (int i = 0; i < q; i++)
{
var txy = Console.ReadLine().Split().Select(int.Parse).ToArray();
var t = txy[0];
var x = txy[1];
var y = txy[2];
if (t == 1)
{
seg.Operate(x, y);
}
else
{
Console.WriteLine(seg.Query(x, y));
}
}
}
public static void Main()
{
int n = int.Parse(Console.ReadLine());
var p = Console.ReadLine().Split().Select(int.Parse).ToArray();
var q = Console.ReadLine().Split().Select(int.Parse).ToArray();
List <int>[] indOfDivs = Enumerable.Repeat(0, n + 1).Select(_ => new List <int>()).ToArray();
for (int i = 0; i < p.Length; i++)
{
for (int j = p[i]; j <= n; j += p[i])
{
indOfDivs[j].Add(i);
}
}
// dp[i] := p を i 番目まで使って長さ k
SegmentTree <int> dp = new SegmentTree <int>(n, 0, Max);
foreach (var item in q)
{
foreach (var ind in indOfDivs[item].Reverse <int>())
{
dp.Operate(ind, dp.Query(0, ind - 1) + 1);
}
}
Console.WriteLine(dp.Query(0, n - 1));
}
static void Main()
{
var n = int.Parse(Console.ReadLine());
//小さい方から見ていく
//前に行くならできる限り前の奴が行ったほうがいいので、pqに突っ込む? いや、そこまでで一番こっちのものなのでセグ木
var a = Enumerable.Repeat(0, n).Select(_ => int.Parse(Console.ReadLine())).ToArray();
var orderedGroup = a.Select((Elem, Ind) => new { Elem, Ind }).GroupBy(x => x.Elem).OrderBy(x => x.Key).ToArray();
SegmentTree <IntTuple> segTree = new SegmentTree <IntTuple>(Enumerable.Range(0, n).Select(x => new IntTuple(x, 0)).ToArray(), new IntTuple(-1, 0), (x, y) => y.Count == 0 ? x : y);
var res = 0;
foreach (var group in orderedGroup)
{
//それぞれがどれから遷移するかを纏める
foreach (var item in group)
{
var least = segTree.Query(0, item.Ind);
if (least.Count != 0)
{
segTree[least.Ind] = new IntTuple(least.Ind, least.Count - 1);
}
else
{
res++;
}
}
foreach (var item in group)
{
var cur = segTree[item.Ind];
segTree[item.Ind] = new IntTuple(cur.Ind, cur.Count + 1);
}
}
Console.WriteLine(res);
}
public static void Main()
{
var nm = Console.ReadLine().Split().Select(int.Parse).ToArray();
var n = nm[0];
var m = nm[1];
int[][] sections = Enumerable.Repeat(0, m).Select(_ => Console.ReadLine().Split().Select(x => int.Parse(x) - 1).ToArray()).ToArray();
SegmentTree <int, int> segTree = new SegmentTree <int, int>(Enumerable.Repeat(0, n).ToArray(), 1 << 30, 0, Min, (x, y) => x + y, (x, y) => x + y);
foreach (var section in sections)
{
segTree.Update(section[0], section[1], 1);
}
List <int> res = new List <int>();
for (int i = 0; i < m; i++)
{
if (segTree.Query(sections[i][0], sections[i][1]) <= 1)
{
continue;
}
res.Add(i + 1);
}
Console.WriteLine(res.Count);
if (res.Count != 0)
{
Console.WriteLine(string.Join("\n", res));
}
}
static void Method(string[] args)
{
int n = ReadInt();
string s = Read();
Queue <int>[] poses = new Queue <int> [26];
for (int i = 0; i < 26; i++)
{
poses[i] = new Queue <int>();
}
for (int i = 0; i < n; i++)
{
poses[s[i] - 'a'].Enqueue(i);
}
int[] deltas = new int[n];
for (int i = 0; i < n; i++)
{
deltas[i] = poses[s[n - 1 - i] - 'a'].Dequeue() - i;
}
var tree = new SegmentTree <int>(n, (a, b) => a + b, 0, 0);
long res = 0;
for (int i = 0; i < n; i++)
{
int to = i + deltas[i];
int newDelta = tree.Scan(to + 1, n - 1);
res += newDelta;
tree.Update(to, 1);
}
WriteLine(res);
}
void Solve()
{
var x = G().ToList();
int N = x[0], Q = x[1], A = x[2] - 1, B = x[3] - 1;
x = G().Select(a => a - 1).ToList();
x.Insert(0, A);
var l = new SegmentTree(N);
var r = new SegmentTree(N);
l[B] = -B;
r[B] = B;
for (var i = 1; i <= Q; i++)
{
var tmp = Min(l.Min(0, x[i]) + x[i], r.Min(x[i], N) - x[i]);
var d = Abs(x[i] - x[i - 1]);
l.Shift(d);
r.Shift(d);
l[x[i - 1]] = -x[i - 1] + tmp;
r[x[i - 1]] = x[i - 1] + tmp;
}
var ans = l[0];
for (var i = 1; i < N; i++)
{
ans = Min(ans, l[i] + i);
}
WriteLine(ans);
}
static void Main()
{
int[] nq = Console.ReadLine().Split().Select(int.Parse).ToArray();
int n = nq[0];
int q = nq[1];
List <int> res = new List <int>();
SegmentTree <int> rsq = new SegmentTree <int>(n, 0, (x, y) => x + y);
for (int i = 0; i < q; i++)
{
int[] cxy = Console.ReadLine().Split().Select(int.Parse).ToArray();
int c = cxy[0];
int x = cxy[1];
int y = cxy[2];
if (c == 0)
{
rsq[x - 1] += y;
}
else
{
res.Add(rsq.Query(x - 1, y - 1));
}
}
Console.WriteLine(string.Join("\n", res));
}
static void Main()
{
var n = int.Parse(Console.ReadLine());
var a = Console.ReadLine().Split().Select(int.Parse).ToArray();
var M = 1000000007;
var f = new long[n + 1];
f[0] = 1;
for (int i = 0; i < n; i++)
{
f[i + 1] = f[i] * (i + 1) % M;
}
var r = 0L;
var st = new SegmentTree(n + 1);
for (int i = 0; i < n; i++)
{
var c = st.Sum(0, a[i]);
r = (r + (a[i] - c - 1) * f[n - i - 1]) % M;
st.Add(a[i], 1);
}
Console.WriteLine(r + 1);
}
public static void Main()
{
var nk = Console.ReadLine().Split().Select(int.Parse).ToArray();
var n = nk[0];
var k = nk[1];
var p = Console.ReadLine().Split().Select(int.Parse).ToArray();
long res = 1;
SegmentTree <Incr> isIncr = new SegmentTree <Incr>(p.Select(x => new Incr()
{
L = x, R = x, Valid = true
}).ToArray(), new Incr()
{
Valid = true, L = int.MaxValue, R = int.MinValue
}, Incr.Merge);
SegmentTree <int> rmin = new SegmentTree <int>(p, int.MaxValue, Min);
SegmentTree <int> rmax = new SegmentTree <int>(p, int.MinValue, Max);
long incrCount = isIncr.Query(0, k - 1).Valid ? 1 : 0;
for (int i = 1; i <= n - k; i++)
{
if (rmax.Query(i, i + k - 1) != p[i + k - 1] || rmin.Query(i - 1, i + k - 2) != p[i - 1])
{
if (isIncr.Query(i, i + k - 1).Valid)
{
incrCount++;
}
res++;
}
}
Console.WriteLine(res - (incrCount <= 1 ? 0 : incrCount - 1));
}
public void AddTest()
{
SegmentTree st = new SegmentTree(0, 16);
st.Add(6, 12);
Assert.IsNotNull(st.Root.LeftChild);
Assert.IsNotNull(st.Root.RightChild);
Assert.IsNotNull(st.Root.LeftChild.RightChild);
Assert.IsNotNull(st.Root.RightChild.LeftChild);
Assert.IsNotNull(st.Root.LeftChild.RightChild.RightChild);
Assert.IsNull(st.Root.LeftChild.LeftChild);
Assert.IsNull(st.Root.RightChild.RightChild);
Assert.IsNull(st.Root.LeftChild.RightChild.LeftChild);
Assert.IsFalse(st.Root.Exist);
Assert.IsFalse(st.Root.LeftChild.Exist);
Assert.IsFalse(st.Root.RightChild.Exist);
Assert.IsFalse(st.Root.LeftChild.RightChild.Exist);
Assert.IsTrue(st.Root.RightChild.LeftChild.Exist);
Assert.IsTrue(st.Root.LeftChild.RightChild.RightChild.Exist);
// Add (0, 2)
st.Add(0, 16);
Assert.IsTrue(st.Root.Exist);
Assert.IsNull(st.Root.LeftChild);
Assert.IsNull(st.Root.RightChild);
}
static void Method(string[] args)
{
int q = ReadInt();
SegmentTree <int> segTree = new SegmentTree <int>(200010, (a, b) => a + b, 0, 0);
for (int i = 0; i < q; i++)
{
int[] tx = ReadInts();
int t = tx[0];
int x = tx[1];
if (t == 1)
{
segTree.Update(x, 1);
}
else
{
int bottom = 0;
int top = 200010;
while (bottom + 1 < top)
{
int mid = (bottom + top) / 2;
if (segTree.Scan(1, mid) < x)
{
bottom = mid;
}
else
{
top = mid;
}
}
WriteLine(top);
segTree.Update(top, 0);
}
}
}
public void TestSimpleAdd ()
{
var collection = new SegmentTree<TreeSegment> ();
collection.Add (new TreeSegment (10, 10));
collection.Add (new TreeSegment (12, 2));
collection.Add (new TreeSegment (14, 2));
collection.Add (new TreeSegment (11, 5));
Assert.AreEqual (4, collection.Segments.Count ());
}
public SegmentTree(int l, int r)
{
s = l;
e = r;
if (e > s)
{
int m = s + (e - s) / 2;
left = new SegmentTree(s, m);
right = new SegmentTree(m + 1, e);
}
}
public void TestUpdateOnTextReplace ()
{
var collection = new SegmentTree<TreeSegment> ();
collection.Add (new TreeSegment (0, 89));
collection.Add (new TreeSegment (92, 51));
collection.Add (new TreeSegment (42, 77));
collection.Add (new TreeSegment (36, 128));
collection.UpdateOnTextReplace (this, new DocumentChangeEventArgs (0, new string(' ', 355), null));
Assert.AreEqual (0, collection.Count);
}
public void TestGetSegmentsOverlapping ()
{
var collection = new SegmentTree<TreeSegment> ();
collection.Add (new TreeSegment (10, 10));
collection.Add (new TreeSegment (12, 2));
collection.Add (new TreeSegment (14, 2));
collection.Add (new TreeSegment (11, 5));
Assert.AreEqual (4, collection.GetSegmentsOverlapping (12, 4).Count ());
Assert.AreEqual (2, collection.GetSegmentsOverlapping (10, 1).Count ());
}
public void TestGetSegmentsAt ()
{
var collection = new SegmentTree<TreeSegment> ();
collection.Add (new TreeSegment (10, 10));
collection.Add (new TreeSegment (12, 2));
collection.Add (new TreeSegment (14, 2));
collection.Add (new TreeSegment (11, 5));
Assert.AreEqual (0, collection.GetSegmentsAt (9).Count ());
Assert.AreEqual (0, collection.GetSegmentsAt (21).Count ());
Assert.AreEqual (1, collection.GetSegmentsAt (10).Count ());
Assert.AreEqual (2, collection.GetSegmentsAt (11).Count ());
Assert.AreEqual (3, collection.GetSegmentsAt (12).Count ());
Assert.AreEqual (3, collection.GetSegmentsAt (15).Count ());
}
public void TestSimpleRemove ()
{
var collection = new SegmentTree<TreeSegment> ();
var seg1 = new TreeSegment (10, 10);
collection.Add (seg1);
var seg2 = new TreeSegment (12, 2);
collection.Add (seg2);
var seg3 = new TreeSegment (14, 2);
collection.Add (seg3);
var seg4 = new TreeSegment (11, 5);
collection.Add (seg4);
collection.Remove (seg2);
Assert.AreEqual (3, collection.Segments.Count ());
collection.Remove (seg4);
Assert.AreEqual (2, collection.Segments.Count ());
}
public virtual void Dispose()
{
if (doc != null)
{
if (segmentMarkerTree != null)
segmentMarkerTree.RemoveListener();
if (invalidCodeRegionTree != null)
invalidCodeRegionTree.RemoveListener();
}
GuiDocument = null;
if (cancelTokenSource != null)
cancelTokenSource.Cancel();
PropertyService.PropertyChanged -= HandlePropertyChanged;
GlobalParseCache.ParseTaskFinished -= GlobalParseCacheFilled;
segmentMarkerTree = null;
invalidCodeRegionTree = null;
}
protected override void OnDocumentSet(EventArgs e)
{
base.OnDocumentSet(e);
if (doc != null)
{
segmentMarkerTree = new SegmentTree<TextSegmentMarker>();
segmentMarkerTree.InstallListener(doc);
invalidCodeRegionTree = new SegmentTree<TreeSegment>();
invalidCodeRegionTree.InstallListener(doc);
}
else
{
segmentMarkerTree = null;
invalidCodeRegionTree = null;
}
}
public void ClearFoldSegments ()
{
InterruptFoldWorker ();
foldSegmentTree = new SegmentTree<FoldSegment> ();
foldSegmentTree.tree.NodeRemoved += HandleFoldSegmentTreetreeNodeRemoved;
foldedSegments.Clear ();
InformFoldTreeUpdated ();
}
private void Run(TextReader rd)
{
N = int.Parse(rd.ReadLine());
this.rd = rd;
tree = new SegmentTree(N, Count);
int Q = int.Parse(rd.ReadLine());
for (; Q > 0; Q--) {
string[] ln = rd.ReadLine().Split(' ');
var t = ln[0];
QueryType type = QueryType.C;
if (t == "X") type = QueryType.X;
else if (t == "Y") type = QueryType.Y;
Solve(int.Parse(ln[1]), int.Parse(ln[2]), type);
}
//Console.ReadKey();
}
public static void Main(string[] args)
{
int n = Convert.ToInt32(Console.ReadLine().ToString());
// Get and store all points
List<Point> points = new List<Point>();
for (int i = 0; i < n; ++i)
{
string[] arr_t = Console.ReadLine().Split(' ');
int[] arr = Array.ConvertAll(arr_t, Int32.Parse);
points.Add(new Point(arr[0], arr[1]));
}
// Build Segment Tree
SegmentTree sgTree = new SegmentTree(points.ToArray(), points.Count);
// Get number of queries and parse
int q = Convert.ToInt32(Console.ReadLine().ToString());
// Preprocess queries
// Count X and Y flips
// If odd then flip once
// Remove all others.
bool[] XFlips = new bool[n + 1];
bool[] YFlips = new bool[n + 1];
System.IO.StreamWriter foutput = new System.IO.StreamWriter("output.txt");
for (int i = 0; i < q; ++i)
{
// Process query
string rawQuery = Console.ReadLine();
string[] sQuery = rawQuery.Split(' ');
string type = sQuery[0];
int q_i = Convert.ToInt32(sQuery[1]) - 1;
int q_j = Convert.ToInt32(sQuery[2]) - 1;
if (type == "C")
{
// Print Result
// Processes points (inclusive)
int[] count = sgTree.Query(q_i + 1, q_j + 1).getArray();
// Print to console
Console.WriteLine("{0} {1} {2} {3}", count[0], count[1], count[2], count[3]);
StringBuilder line = new StringBuilder();
line.AppendFormat("{0} {1} {2} {3}", count[0], count[1], count[2], count[3]);
foutput.WriteLine(line);
}
else if (type == "X")
{
//// Process query X
sgTree.Update(q_i + 1, q_j + 1, QType.X);
}
else
{
//// Process query Y
sgTree.Update(q_i + 1, q_j + 1, QType.Y);
}
}
// Close file
foutput.Close();
}
public void ClearFoldSegments ()
{
InterruptFoldWorker ();
foldSegmentTree.RemoveListener (this);
foldSegmentTree = new SegmentTree<FoldSegment> ();
foldSegmentTree.InstallListener (this);
InformFoldTreeUpdated ();
}
