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);
}
public void AddTest_MergeNode()
{
SegmentTree st = new SegmentTree(0, 16);
st.Add(0, 8);
st.Add(8, 16);
Assert.IsNull(st.Root.LeftChild);
Assert.IsNull(st.Root.RightChild);
Assert.IsTrue(st.Root.Exist);
}
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 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 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 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 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 TextChangeEventArgs(0, 0, new string(' ', 355), null));
Assert.AreEqual(0, collection.Count);
}
private void button1_Click(object sender, EventArgs e)
{
//test segment tree,
//with overlapped segment ...
TreeSegment t1 = new TreeSegment(0, 10);
TreeSegment t2 = new TreeSegment(8, 20);
SegmentTree <TreeSegment> tree1 = new SegmentTree <TreeSegment>();
tree1.Add(t1);
tree1.Add(t2);
foreach (var seg in tree1.GetSegmentsAt(9))
{
}
}
public void AddTest_RemoveChildren()
{
SegmentTree st = new SegmentTree(0, 16);
st.Add(0, 8);
Assert.IsNotNull(st.Root.LeftChild);
Assert.IsNull(st.Root.RightChild);
Assert.IsFalse(st.Root.Exist);
Assert.IsTrue(st.Root.LeftChild.Exist);
st.Add(0, 16);
Assert.IsNull(st.Root.LeftChild);
Assert.IsNull(st.Root.RightChild);
Assert.IsTrue(st.Root.Exist);
}
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 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 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 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 ());
}
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 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 void RemoveTest_RemoveAll()
{
SegmentTree st = new SegmentTree(0, 16);
st.Add(2, 4);
st.Remove(2, 4);
Assert.IsNull(st.Root);
}
public void TestInsertAtEnd ()
{
var collection = new SegmentTree<TreeSegment> ();
collection.Add (new TreeSegment (10, 0));
collection.UpdateOnTextReplace (this, new TextChangeEventArgs (10, 10, null, "\n"));
var seg = collection.Segments.First ();
Assert.AreEqual (10, seg.Offset);
}
public void RemoveTest_SplitExistNode()
{
SegmentTree st = new SegmentTree(0, 16);
st.Add(0, 16);
st.Remove(0, 8);
Assert.IsFalse(st.Root.Exist);
Assert.IsNull(st.Root.LeftChild);
Assert.IsNotNull(st.Root.RightChild);
Assert.IsTrue(st.Root.RightChild.Exist);
}
public static int Solve(int[] t)
{
int n = t.Length;
int left, right, b;
SegmentTree segmentTree = new SegmentTree();
for (int i = 0; i < n; i++)
{
if (t[i] <= n - 1)
{
right = (i - t[i] + n) % n;
left = i + 1;
if (left <= right)
{
segmentTree.Add(left, right);
}
else
{
segmentTree.Add(left, n - 1);
segmentTree.Add(0, right);
}
}
}
int v = 0;
int index = 0;
for (int i = 0; i < n; i++)
{
b = segmentTree.Get(i);
if (b > v)
{
v = b;
index = i;
}
}
return(index + 1);
}
public void InvalidInputTest()
{
SegmentTree st = new SegmentTree(0, 16);
st.Add(6, 10);
try
{
st.Query(-3, 10);
}
catch (ArgumentException e)
{
Assert.AreEqual("Valid number must be in the interval [0, 16)", e.Message);
}
}
public static long Solve(long[] a, int n)
{
long result = 0;
SegmentTree st = new SegmentTree(1, 10000000);
for (int i = 0; i < n; i++)
{
result += st.Get(a[i]);
st.Add(a[i]);
}
return(result);
}
public void RemoveTest_RemoveLeaf()
{
SegmentTree st = new SegmentTree(0, 16);
st.Add(2, 8);
st.Remove(2, 4);
Assert.IsNull(st.Root.LeftChild.LeftChild);
Assert.IsNotNull(st.Root.LeftChild.RightChild);
Assert.IsTrue(st.Root.LeftChild.RightChild.Exist);
Assert.IsFalse(st.Root.Exist);
Assert.IsFalse(st.Root.LeftChild.Exist);
}
public void QueryTest()
{
SegmentTree st = new SegmentTree(0, 16);
st.Add(6, 10);
Assert.IsTrue(st.Query(6, 10));
Assert.IsTrue(st.Query(6, 8));
Assert.IsTrue(st.Query(8, 10));
Assert.IsFalse(st.Query(0, 4));
Assert.IsFalse(st.Query(0, 6));
Assert.IsFalse(st.Query(4, 10));
Assert.IsFalse(st.Query(8, 11));
Assert.IsFalse(st.Query(10, 16));
}
public void TestLenth1InsertionMove()
{
// use case:
// {|_}
// marked } with markerlength == 1 - typing the caret should move the marker according to } before it stayed in place and got overtyped.
var collection = new SegmentTree <TreeSegment> ();
collection.Add(new TreeSegment(216, 1));
collection.UpdateOnTextReplace(this, new TextChangeEventArgs(216, 10, null, "\n"));
var seg = collection.Segments.First();
Assert.AreEqual(217, seg.Offset);
Assert.AreEqual(1, seg.Length);
}
public void Add(int p)
{
if (p <= e && p >= s)
{
count++;
if (left != null)
{
left.Add(p);
}
if (right != null)
{
right.Add(p);
}
}
}
static void Main()
{
var n = int.Parse(Console.ReadLine());
var a = Console.ReadLine().Split().Select(int.Parse).ToArray();
var r = 0L;
var st = new SegmentTree(n + 1);
for (int i = 0; i < n; i++)
{
r += i - st.Sum(0, a[i] + 1);
st.Add(a[i], 1);
}
Console.WriteLine(r);
}
public Projection(ITextDocument document, IReadOnlyList <ProjectedSegment> projectedSegments)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
this.Document = document;
for (int i = 0; i < projectedSegments.Count; i++)
{
var p = projectedSegments [i];
var original = new ProjectedTreeSegment(p.Offset, p.Length);
var projected = new ProjectedTreeSegment(p.ProjectedOffset, p.Length);
original.LinkedTo = projected;
projected.LinkedTo = original;
originalProjections.Add(original);
projectedProjections.Add(projected);
}
}
public ulong Solve()
{
SegmentTree tree = new SegmentTree()
{
Max = this.M
};
ulong sum = 0;
ulong result = 0;
for (int i = 0; i < this.A.Length; i++)
{
sum = (sum + this.A[i]) % this.M;
result = Math.Max(result, sum);
ulong next = tree.Get(sum + 1);
result = Math.Max(result, sum + this.M - next);
tree.Add(sum);
}
return(result);
}
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 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 ());
}
