public FlatXml Parse(XmlReader reader) { var nodes = new SortedSet<FlatXmlNode>(); var position = 0; while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: var element = new FlatXmlNode {Name = reader.Name, Depth = reader.Depth, Position = position}; nodes.Add(element); if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { position += 1; var attribute = new FlatXmlNode {Name = reader.Name, Value = reader.Value, Position = position, Depth = reader.Depth}; nodes.Add(attribute); } } break; case XmlNodeType.Text: var t = new FlatXmlNode {Value = reader.Value, Depth = reader.Depth, Position = position}; nodes.Add(t); break; } position += 1; } return new FlatXml(nodes); }
public static void AddMembers(this IMemberContainer parent, MemberDeclarationSyntax s, SortedSet <FieldInfo> fields = null, SortedSet <PropertyInfo> properties = null, SortedSet <IndexerInfo> indexers = null, SortedSet <MemberInfoBase> methods = null) { // ugly but works switch (s) { case FieldDeclarationSyntax decl: fields?.Add(new FieldInfo(decl, parent)); break; case PropertyDeclarationSyntax decl: properties?.Add(new PropertyInfo(decl, parent)); break; case IndexerDeclarationSyntax decl: indexers?.Add(new IndexerInfo(decl, parent)); break; case MethodDeclarationSyntax decl: methods?.Add(new MethodInfo(decl, parent)); break; case ConstructorDeclarationSyntax decl: methods?.Add(new ConstructorInfo(decl, parent)); break; case OperatorDeclarationSyntax decl: methods?.Add(new OperatorInfo(decl, parent)); break; } }
public static void Main() { var numberOfDigits = int.Parse(Console.ReadLine()); var digits = new int[numberOfDigits]; for (int i = 0; i < numberOfDigits; i++) { digits[i] = int.Parse(Console.ReadLine()); } Array.Sort(digits); var allNumbers = new HashSet<int>(); PermuteRep(digits, 0, digits.Length, allNumbers); var numbersWithMinNumberOfDivisors = new SortedSet<int>(); var minCountOfDivisors = 10000; foreach (var number in allNumbers) { var divisorsCount = CalculateDivisors(number); if (divisorsCount < minCountOfDivisors) { numbersWithMinNumberOfDivisors.Clear(); numbersWithMinNumberOfDivisors.Add(number); minCountOfDivisors = divisorsCount; } else if (divisorsCount == minCountOfDivisors) { numbersWithMinNumberOfDivisors.Add(number); } } Console.WriteLine(numbersWithMinNumberOfDivisors.Min); }
static void Main(string[] args) { primes = new SortedSet<int>(); not_primes = new SortedSet<int>(); primes.Add(2); primes.Add(3); primes.Add(5); primes.Add(7); not_primes.Add(9); maxNumPrimes = 0; foreach(int a in Enumerable.Range(0, 1000)) { foreach(int b in Enumerable.Range(0, 1000)) { TestQuadratic(a, b); TestQuadratic(-a, b); TestQuadratic(a, -b); TestQuadratic(-a, -b); } } Console.WriteLine(maxNumPrimes); Console.WriteLine(maxA * maxB); Console.ReadLine(); }
/// <summary> /// FanIn /// </summary> public IEnumerable<Activity> Load(Feed feed) { var snapshot = new Dictionary<byte[], Queue<Activity>>(activityStreamStore.Count); foreach (var item in activityStreamStore) { snapshot.Add(item.Key, new Queue<Activity>(item.Value)); } SortedSet<Activity> buffer = new SortedSet<Activity>(Activity.Comparer); var streams = feed.FeedStreams.ToList(); var streamsCount = streams.Count; // Init for (int streamIndexInsideSubsciption = 0; streamIndexInsideSubsciption < streamsCount; streamIndexInsideSubsciption++) { var streamId = streams[streamIndexInsideSubsciption]; var activity = snapshot[streamId].Dequeue(); buffer.Add(activity); } while (buffer.Count > 0) { Activity nextActivity = buffer.FirstOrDefault(); buffer.Remove(nextActivity); var streamQueue = snapshot[nextActivity.StreamId]; if (streamQueue.Count > 0) { var candidate = snapshot[nextActivity.StreamId].Dequeue(); buffer.Add(candidate); } yield return nextActivity; } }
static void Main() { string[] input = Console.ReadLine().Split(new char []{' ',',','.','?','!'},StringSplitOptions.RemoveEmptyEntries); SortedSet<string> palindromes = new SortedSet<string>(); for (int i = 0; i < input.Length; i++) { StringBuilder sb = new StringBuilder(input[i]); if (sb.Length == 1) { palindromes.Add(input[i]); } else { for (int j = 0; j < input[i].Length/2; j++) { if (sb[j].Equals(sb[sb.Length - 1 - j])) { palindromes.Add(input[i]); } } } } Console.Write(string.Join(", ",palindromes)); Console.WriteLine(); }
private int FindLongestPath(int maxSalary, int startSalary) { IDictionary<int, int> longestPaths = new Dictionary<int, int>() { { startSalary, 1 }}; SortedSet<int> salaries = new SortedSet<int>(); salaries.Add(startSalary); while (salaries.Count != 0) { int salary = salaries.Min; int path = longestPaths[salary]; foreach (int nextSalary in GetNextSalaries(maxSalary, salary)) { if (!salaries.Contains(nextSalary)) { salaries.Add(nextSalary); longestPaths.Add(nextSalary, path + 1); } else if (longestPaths[nextSalary] < path + 1) longestPaths[nextSalary] = path + 1; } salaries.Remove(salary); } return longestPaths.Values.Max(); }
static void Main() { string text = Console.ReadLine(); char[] splitters = { ' ', '.', ',', '!', '?' }; string[] word = text.Split(splitters, StringSplitOptions.RemoveEmptyEntries); SortedSet<string> palyndromes = new SortedSet<string>(); for (int i = 0; i < word.Length; i++) { string wordToCheck = word[i]; int len = wordToCheck.Length; int halflen = len / 2; if (len == 1) { palyndromes.Add(wordToCheck); } else { string firstpart = wordToCheck.Substring(0, halflen); char[] temp = wordToCheck.Substring(len - halflen).ToCharArray(); Array.Reverse(temp); string secondpart = new string(temp); if (firstpart == secondpart) { palyndromes.Add(wordToCheck); } } } Console.WriteLine(String.Join(", ", palyndromes)); }
public int find(int[] array, int k) { if (array == null || array.Length == 0) return -1; SortedSet<int> queue = new SortedSet<int>(); int maxItem = array[0]; queue.Add(array[0]); foreach (int v in array) { if (queue.Count < k) queue.Add(v); // can enqueue else if (v < queue.Max) { queue.Remove(queue.Max); queue.Add(v); } } int res = -1; foreach (var v in queue) { if (--k == 0) { res = v; break; } } return res; }
internal GetGeneratedEventsResults Generate(Type baseType, SortedSet<string> namespaces, NameGenerator generator, MethodInformationBuilder builder) { var requiresObsoleteSuppression = false; var generatedEvents = new List<string>(); foreach (var @event in baseType.GetMockableEvents(generator)) { var eventHandlerType = @event.EventHandlerType; namespaces.Add(eventHandlerType.Namespace); var eventMethod = @event.AddMethod; var methodInformation = builder.Build(new MockableResult<MethodInfo>( eventMethod, RequiresExplicitInterfaceImplementation.No)); var @override = methodInformation.DescriptionWithOverride.Contains("override") ? "override " : string.Empty; if (eventMethod.IsPublic) { if (eventHandlerType.IsGenericType) { var eventGenericType = eventHandlerType.GetGenericArguments()[0]; generatedEvents.Add(EventTemplates.GetEvent(@override, $"EventHandler<{eventGenericType.GetSafeName()}>", @event.Name)); namespaces.Add(eventGenericType.Namespace); } else { generatedEvents.Add(EventTemplates.GetEvent(@override, eventHandlerType.GetSafeName(), @event.Name)); } requiresObsoleteSuppression |= @event.GetCustomAttribute<ObsoleteAttribute>() != null; } else if (!eventMethod.IsPrivate && eventMethod.IsAbstract) { var visibility = CodeTemplates.GetVisibility(eventMethod.IsFamily, eventMethod.IsFamilyOrAssembly); if (eventHandlerType.IsGenericType) { var eventGenericType = eventHandlerType.GetGenericArguments()[0]; generatedEvents.Add(EventTemplates.GetNonPublicEvent(visibility, $"EventHandler<{eventGenericType.GetSafeName()}>", @event.Name)); namespaces.Add(eventGenericType.Namespace); } else { generatedEvents.Add(EventTemplates.GetNonPublicEvent(visibility, eventHandlerType.GetSafeName(), @event.Name)); } requiresObsoleteSuppression |= @event.GetCustomAttribute<ObsoleteAttribute>() != null; } } return new GetGeneratedEventsResults(generatedEvents.AsReadOnly(), requiresObsoleteSuppression); }
/// <summary> /// Core method for generating normal pager items according to the page information. /// </summary> /// <param name="currentPage">The current page number.</param> /// <param name="totalPage">The count of total pages.</param> /// <param name="expandForCurrentPage">How many pages should be expanded for current page.</param> /// <param name="expandForEnding">How many pages should be expanded for ending.</param> /// <returns></returns> private static IEnumerable<PagerItem> GeneratePagerNormalItems(int currentPage, int totalPage, int expandForCurrentPage, int expandForEnding) { var pageNumberList = new SortedSet<int> {currentPage}; // Expand for current page for (var i = 1; i <= expandForCurrentPage; i++) { pageNumberList.Add(currentPage + i); pageNumberList.Add(currentPage - i); } // Expand for ending for (var i = 1; i <= expandForEnding; i++) { pageNumberList.Add(i); pageNumberList.Add(totalPage + 1 - i); } // Remove invalid items pageNumberList.RemoveWhere(i => i < 1 || i > totalPage); var lastPageNumber = 0; foreach (var i in pageNumberList) { // Skipped some item if (i - lastPageNumber > 1) { yield return new PagerItem { ItemType = PagerItemType.Omitted, PageNumber = -1 }; } yield return new PagerItem { // is current page ItemType = i == currentPage ? PagerItemType.Current : PagerItemType.Normal, PageNumber = i }; // Set last page lastPageNumber = i; } // last page omit handling if (lastPageNumber < totalPage) { yield return new PagerItem { ItemType = PagerItemType.Omitted, PageNumber = -1 }; } }
static void Main() { int n = int.Parse(Console.ReadLine()); var noIncommingEdges = new SortedSet<char>(); for (int i = 0; i < n; i++) { string currentMessage = Console.ReadLine(); Node previousNode = GetNodeByCharFromGraph(currentMessage[0]); for (int j = 1; j < currentMessage.Length; j++) { Node currentNode = GetNodeByCharFromGraph(currentMessage[j]); previousNode.Successors.Add(currentNode); currentNode.Parents.Add(previousNode); previousNode = currentNode; } } foreach (var node in graph.Values) { if (node.Parents.Count == 0) { noIncommingEdges.Add(node.Value); } } var result = new List<char>(); while (noIncommingEdges.Count > 0) { var currentNodeSymbol = noIncommingEdges.Min; noIncommingEdges.Remove(currentNodeSymbol); result.Add(currentNodeSymbol); var currentNode = graph[currentNodeSymbol]; var children = currentNode.Successors.ToList(); foreach (var child in children) { child.Parents.Remove(currentNode); currentNode.Successors.Remove(child); if (child.Parents.Count == 0) { noIncommingEdges.Add(child.Value); } } } Console.WriteLine(String.Join("", result)); }
public override void Initialize() { base.Initialize(); new ControlHandler(this); _collided = new SortedSet<string>(); Page p = new Page(this, "Page"); p.Show(); _collidedLabel = new Label(p, "CollidedLabel", new Point(0, 0)); _collidedLabel.Body.Position = new Vector2(10, 560); for (int x = 0; x < 3; x++) { ResolutionTestNode c = new ResolutionTestNode(this, "A" + x); c.Collision.Group.AddMask(0); c.Collision.Pair.AddMask(0); c.Collision.Pair.AddMask(2); c.Collision.ResolutionGroup.AddMask(0); c.Collision.ResolutionGroup.AddMask(1); c.Collision.ResolutionGroup.AddMask(2); c.Collision.CollideEvent += manifold => _collided.Add(manifold.A != c.Collision ? manifold.A.Parent.Name : manifold.B.Parent.Name); c.Collision.Debug = true; c.Body.Position = new Vector2(30, 80 * x + 20); } for (int x = 0; x < 3; x++) { ResolutionTestNode c = new ResolutionTestNode(this, "B" + x); c.Collision.Group.AddMask(1); c.Collision.Pair.AddMask(0); c.Collision.Pair.AddMask(2); c.Collision.ResolutionGroup.AddMask(0); c.Collision.CollideEvent += manifold => _collided.Add(manifold.A != c.Collision ? manifold.A.Parent.Name : manifold.B.Parent.Name); c.Collision.Debug = true; c.Body.Position = new Vector2(510, 80 * x + 20); c.Color = Color.Orange; c.HoverColor = Color.Violet; } for (int x = 0; x < 3; x++) { ResolutionTestNode c = new ResolutionTestNode(this, "C" + x); c.Collision.Group.AddMask(2); c.Collision.Pair.AddMask(0); c.Collision.Pair.AddMask(1); c.Collision.ResolutionGroup.AddMask(0); c.Collision.ResolutionGroup.AddMask(1); c.Collision.CollideEvent += manifold => _collided.Add(manifold.A != c.Collision ? manifold.A.Parent.Name : manifold.B.Parent.Name); c.Collision.Immovable = true; c.Collision.Debug = true; c.Body.Position = new Vector2(50 + x * 70, 450); c.Color = Color.Green; c.HoverColor = Color.DarkBlue; } }
public void WordBreakIITestErrorCase() { WordBreakII wb = new WordBreakII(); SortedSet<string> wordset = new SortedSet<string>(); wordset.Add("aaaa"); wordset.Add("aaa"); List<string> strs = (List<string>)wb.WordBreak("aaaaaaa", wordset); List<string> target = new List<string>() { "aaaa aaa", "aaa aaaa" }; Assert.IsTrue(isListEqual(target, strs)); }
public static Stack<Square> Search(Map map, Square source, Square target, Func<Square, Square, int> heuristic) { Dictionary<Square, Square> parents = new Dictionary<Square, Square>(); HashSet<Square> closed = new HashSet<Square>(); SortedSet<Square> open = new SortedSet<Square>(); source.Score.Cost = 0; source.Score.Estimate = heuristic(source, target); open.Add(source); while (open.Count > 0) { // Get node with lowest f(x) score Square current = open.First(); if (current == target) break; // Transfer node to closed set open.Remove(current); closed.Add(current); // Examine neighbors foreach (Square neighbor in map.GetNeighbors(current)) { // Check if node is already processed or not passable if (closed.Contains(neighbor) || (neighbor != target && !neighbor.IsPassable)) continue; // Tentative g score float g = current.Score.Cost + 1; // Add (new) node to open if (!open.Contains(neighbor)) { parents[neighbor] = current; neighbor.Score.Cost = g; neighbor.Score.Estimate = heuristic(neighbor, target); open.Add(neighbor); } // Updating existing node in open else if (g < neighbor.Score.Cost) { open.Remove(neighbor); parents[neighbor] = current; neighbor.Score.Cost = g; open.Add(neighbor); } } } return ReconstructPath(parents, target); }
private int _maxProcessingTimeFromStart; //The answer to the big question #endregion Fields #region Constructors public Store(int cashierCount) { Debug.Assert(cashierCount > 0, "Invalid number of cashiers specified. Must be greater than zero"); CashierIdGenerator.Reset(); _cashiers = new SortedSet<ICashier>(); for (int i = 0; i < cashierCount - 1; i++) { _cashiers.Add(new Cashier(CashierIdGenerator.NextCashierId)); } _cashiers.Add(new CashierTrainee(CashierIdGenerator.NextCashierId)); }
static void Main(string[] args) { primes = new SortedSet<uint>(); primes.Add(2); primes.Add(3); uint n; uint.TryParse(args[0], out n); Console.WriteLine(NthPrime(n)); Console.ReadLine(); }
public DataCollector() { Paths = new Dictionary<string, List<PathData>>(); Ranks = new SortedSet<string>(); CurrentTag = "0"; Tags = new SortedDictionary<string, string>(); EffectTags = new SortedDictionary<string, string>(); Races = new SortedSet<string>(); Ranks.Add("boss"); Ranks.Add("thrash"); }
public void WordBreakIITestExample() { WordBreakII wb = new WordBreakII(); SortedSet<string> wordset = new SortedSet<string>(); wordset.Add("cat"); wordset.Add("cats"); wordset.Add("and"); wordset.Add("sand"); wordset.Add("dog"); List<string> strs = (List<string>)wb.WordBreak("catsanddog", wordset); List<string> target = new List<string>(){"cats and dog", "cat sand dog"}; Assert.IsTrue(isListEqual(target, strs)); }
static int NumDividors(uint n) { SortedSet<uint> results = new SortedSet<uint>(); for (uint i = 1; i <= Math.Sqrt(n); i++) { if (n % i == 0) { results.Add(i); results.Add(n / i); } } return results.Count; }
static void Main(string[] args) { SortedSet<int> sortedNumbers = new SortedSet<int>(); sortedNumbers.Add(9); sortedNumbers.Add(9); sortedNumbers.Add(1); sortedNumbers.Add(2); foreach (var item in sortedNumbers) { Console.WriteLine(item); } }
static double Dijkstra(List<List<double>> t, List<List<int>> c, int x, int y, double speed) { int[] dx = new int[] {0, 1, 0, -1}; int[] dy = new int[] {1, 0, -1, 0}; int h = t.Count, w = t[0].Count; bool[,,] seen = new bool[h, w, 2]; double[,,] dist = new double[h, w, 2]; foreach (int i in Enumerable.Range(0, h)) foreach (int j in Enumerable.Range(0, w)) foreach (int k in Enumerable.Range(0, 2)) dist[i, j, k] = 13; foreach (int k in Enumerable.Range(0, 2)) { dist[x, y, k] = 0; SortedSet<Tuple<double, int, int>> q = new SortedSet<Tuple<double, int, int>> (); q.Add(Tuple.Create(0.0, x, y)); while (q.Count > 0) { var best = q.Min; q.Remove(best); if (seen[best.Item2, best.Item3, k]) continue; seen[best.Item2, best.Item3, k] = true; foreach (var z in Enumerable.Range(0, 4) .Select(l => new {X = best.Item2 + dx[l], Y = best.Item3 + dy[l]}) .Where(z => z.X >= 0 && z.X < h && z.Y >= 0 && z.Y < w && Math.Abs(c[best.Item2][best.Item3] - c[z.X][z.Y]) <= 1000)) { double ndist = speed + Math.Max(t[z.X][z.Y] + Convert.ToInt32(k == 0), best.Item1); if (ndist < dist[z.X, z.Y, k]) { dist[z.X, z.Y, k] = ndist; q.Add(Tuple.Create(dist[z.X, z.Y, k], z.X, z.Y)); } } } } return ( from i in Enumerable.Range(0, h) from j in Enumerable.Range(0, w) where dist[i, j, 0] <= 12 - dist[i, j, 1] select Math.Sqrt((i - x) * (i - x) + (j - y) * (j - y)) ).Max(); }
public DataCollector() { DungeonPaths = new Dictionary<string, List<PathData>>(); FractalPaths = new List<PathData>(); RaidPaths = new Dictionary<string, List<PathData>>(); Ranks = new SortedSet<string>(); NextShortTag = "0"; OtherTagToShortTag = new SortedDictionary<string, string>(); EffectTagToShortTag = new SortedDictionary<string, string>(); Races = new SortedSet<string>(); // Special hardcoded ranks. Boss includes champions and legendaries. Thrash includes elites, veterans and normals. Ranks.Add("boss"); Ranks.Add("thrash"); }
public override void Initialize() { base.Initialize(); ControlHandler ch = new ControlHandler(this); _collided = new SortedSet<string>(); Page p = new Page(this, "Page"); p.Show(); _collidedLabel = new Label(p, "CollidedLabel", new Point(0, 0)); _collidedLabel.Body.Position = new Vector2(10, 500); Random rand = new Random(); for (int x = 0; x < 3; x++) { AabbNode c = new AabbNode(this, "A" + x); c.Collision.Group.AddMask(0); c.Collision.Pair.AddMask(0); c.Collision.CollideEvent += manifold => _collided.Add(manifold.A != c.Collision ? manifold.A.Parent.Name : manifold.B.Parent.Name); c.Collision.Debug = true; c.Body.Position = new Vector2(0, 100 * x + 20); c.Shape.Debug = true; } for (int x = 0; x < 3; x++) { AabbNode c = new AabbNode(this, "B" + x); c.Collision.Group.AddMask(1); c.Collision.Pair.AddMask(0); c.Collision.CollideEvent += manifold => _collided.Add(manifold.A != c.Collision ? manifold.A.Parent.Name : manifold.B.Parent.Name); c.Body.Position = new Vector2(510, 80 * x + 20); c.Color = Color.Orange; c.HoverColor = Color.Black; c.Collision.Debug = true; } for (int x = 0; x < 3; x++) { CircleNode c = new CircleNode(this, "C" + x); c.Collision.Group.AddMask(2); c.Collision.Pair.AddMask(2); c.Collision.CollideEvent += manifold => _collided.Add(manifold.A != c.Collision ? manifold.A.Parent.Name : manifold.B.Parent.Name); ; c.Body.Position = new Vector2(80 * x + 20, 300); c.Color = Color.LightBlue; c.HoverColor = Color.DarkRed; c.Shape.Debug = true; } }
private static void F3() { SortedSet<MyPoint> set = new SortedSet<MyPoint>(); set.Add(new MyPoint { x = 20, y = 20 }); set.Add(new MyPoint { x = 11, y = 20 }); set.Add(new MyPoint { x = 22, y = 20 }); set.Add(new MyPoint { x = 20, y = 20 }); set.Add(new MyPoint { x = 20, y = 21 }); foreach (MyPoint p in set) { Console.WriteLine(p.ToString()); } }
// Originally wrote this as a delegate function, changed my mind, this is clearer public static SortedSet<double> GetSeries(double firstNumber, double growthRate, int length) { if (length == 0) return null; var set = new SortedSet<double>(); set.Add(RoundToQuarter(firstNumber)); for (int index = 1; index < length; index++) { double nextInSeries = RoundToQuarter(growthRate*(Math.Pow(firstNumber, index))); set.Add(nextInSeries); } return set; }
public void WillOrderLastClassWithSameScoreFirst() { var set = new SortedSet<BackgroundImageClass>(new SelectorComparer()); set.Add(new BackgroundImageClass("h1{{width:5}}", 1)); set.Add(new BackgroundImageClass("h1{{width:10}}", 2)); BackgroundImageClass result = null; foreach (var backgroundImageClass in set) { result = backgroundImageClass; break; } Assert.Equal(10, result.Width); }
public void WillOrderClassWithHighestSpecificityHighest() { var set = new SortedSet<BackgroundImageClass>(new SelectorComparer()); set.Add(new BackgroundImageClass("h1{{color:blue}}", 0)); set.Add(new BackgroundImageClass("h1#myid{{color:blue}}", 0)); BackgroundImageClass result = null; foreach (var backgroundImageClass in set) { result = backgroundImageClass; break; } Assert.Equal("h1#myid", result.Selector); }
public static void Main() { var priority = new SortedSet<Edge>(); const int numberOfNodes = 6; var used = new bool[numberOfNodes + 1]; var mpdNodes = new List<Edge>(); var edges = new List<Edge>(); edges.Add(new Edge(1, 3, 5)); edges.Add(new Edge(1, 2, 4)); edges.Add(new Edge(1, 4, 9)); edges.Add(new Edge(2, 4, 2)); edges.Add(new Edge(3, 4, 20)); edges.Add(new Edge(3, 5, 7)); edges.Add(new Edge(4, 5, 8)); edges.Add(new Edge(5, 6, 12)); foreach (var edge in edges) { if (edge.StartNode == edges[0].StartNode) { priority.Add(edge); } } used[edges[0].StartNode] = true; FindMinimumSpanningTree(used, priority, mpdNodes, edges); PrintMinimumSpanningTree(mpdNodes); }
private static void FindMinimumSpanningTree(bool[] used, SortedSet<Edge> priority, List<Edge> mpdNodes, List<Edge> edges) { while (priority.Count > 0) { var edge = priority.Min; priority.Remove(edge); if (!used[edge.EndNode]) { used[edge.EndNode] = true; mpdNodes.Add(edge); for (int i = 0; i < edges.Count; i++) { if (!mpdNodes.Contains(edges[i])) { if (edge.EndNode == edges[i].StartNode && !used[edges[i].EndNode]) { priority.Add(edges[i]); } } } } } }
public static void TestCopyConstructor() { SortedSet<int> sortedSet = new SortedSet<int>(); List<int> listOfItems = new List<int>(); for (int i = 0; i < 10000; i++) { if (!sortedSet.Contains(i)) { sortedSet.Add(i); listOfItems.Add(i); } } SortedSet<int> newTree1 = new SortedSet<int>(listOfItems); Assert.True(newTree1.SetEquals(listOfItems)); //"Expected to be the same set." SortedSet<int> newTree2 = new SortedSet<int>(sortedSet); Assert.True(sortedSet.SetEquals(newTree2)); //"Expected to be the same set." Assert.Equal(sortedSet.Count, newTree1.Count); //"Should be equal." Assert.Equal(sortedSet.Count, newTree2.Count); //"Copied tree not the same as base" }
private void FillAssemblyNames(HashSet <AssemblyName> hashSet, IEnumerable <AssemblyName> assemblyNames, ref SortedSet <string> errors) { foreach (AssemblyName assemblyName in assemblyNames.OrderBy(assemblyName => assemblyName.FullName)) { if (hashSet.Add(assemblyName)) { AssemblyName[] referencedAssemblies; try { referencedAssemblies = this.assemblyInformationLoader.GetReferencedAssemblies(assemblyName); } catch (FileNotFoundException) { errors?.Add(assemblyName.FullName); continue; } this.FillAssemblyNames(hashSet, referencedAssemblies, ref errors); } } }
public static void AddChildTypes(this ITypeContainer parent, MemberDeclarationSyntax s, SortedSet <ClassInfo> classes = null, SortedSet <StructInfo> structs = null, SortedSet <InterfaceInfo> interfaces = null, SortedSet <EnumInfo> enums = null) { // ugly but works switch (s) { case ClassDeclarationSyntax decl: new ClassInfo(decl, parent).AddOrReuse(decl, classes); break; case EnumDeclarationSyntax decl: enums?.Add(new EnumInfo(decl, parent)); break; case StructDeclarationSyntax decl: new StructInfo(decl, parent).AddOrReuse(decl, structs); break; case InterfaceDeclarationSyntax decl: new InterfaceInfo(decl, parent).AddOrReuse(decl, interfaces); break; } }
/// <summary> /// Adds a player-owned house to the rent queue /// </summary> private static void AddRentQueue(IPlayer player, House house) { var playerHouse = new PlayerHouse(player, house); RentQueue.Add(playerHouse); }
static void Main(string[] args) { List <string> codes = new List <string>(); using (TextReader reader = File.OpenText("input.txt")) { while (reader.Peek() >= 0) { string line = reader.ReadLine(); codes.Add(line); } } int highestId = 0; SortedSet <int> sortedIds = new SortedSet <int>(); foreach (string code in codes) { Func <string, int, int, char, char, int> BinaryChop = (string str, int lowerStart, int upperStart, char lowerChar, char upperChar) => { int lower = lowerStart; int upper = upperStart; for (int i = 0; i < str.Length; ++i) { int range = upper - lower; if (str[i] == lowerChar) { upper -= range / 2; } else if (str[i] == upperChar) { lower += range / 2; } else { throw new Exception(); } } if (upper - lower != 1) { throw new Exception(); } return(lower); }; string rows = code.Substring(0, 7); int row = BinaryChop(rows, 0, 128, 'F', 'B'); string columns = code.Substring(7, 3); int column = BinaryChop(columns, 0, 8, 'L', 'R'); int id = (row * 8) + column; Console.WriteLine("{0}: row {1} column {2} - ID {3}", code, row, column, id); sortedIds.Add(id); highestId = Math.Max(highestId, id); } Console.WriteLine("Highest ID: {0}", highestId); int lastID = -1; foreach (int id in sortedIds) { if (id - lastID == 2) { Console.WriteLine("ID space at: {0}", lastID + 1); } lastID = id; } }
public static void Main(string[] args) { System.Threading.ThreadPool.SetMinThreads(64, 16); if (args.Length == 1) { foreach (string str in System.IO.File.ReadAllLines(args[0])) { initial.Enqueue(str); } } SortedDictionary <int, System.Threading.Thread> jobs = new SortedDictionary <int, System.Threading.Thread> (); repositories = new SortedDictionary <string, ChunkRepository> (); Modifiers.Add("async"); //BD2.Core.Database DB = new BD2.Core.Database (); string command; do { command = Query("Command>"); if (command == null) { return; } OffsetedArray <string> commandparts = command.Split(' '); string[] CommandParts = (string[])((string[])commandparts).Clone(); commandparts.Offset = ExtractModifiers(CommandParts); SortedSet <string> CommandModifiers = new SortedSet <string> (commandparts.GetStrippedPart()); switch (CommandParts [0]) { case "Run": if (CommandParts.Length < 2) { Console.Error.WriteLine("Run requires at least two parameter: [async] Run <Type>"); continue; } switch (CommandParts [1]) { case "Daemon": if (CommandParts.Length < 3) { Console.Error.WriteLine("Run Daemon requires at least one parameter: [async] Run Daemon <Daemon Type>"); continue; } switch (CommandParts [2]) { case "SQL": if (CommandModifiers.Contains("async")) { System.Threading.Thread t_runSourceDaemon = new System.Threading.Thread(RunSourceDaemon); jobs.Add(t_runSourceDaemon.ManagedThreadId, t_runSourceDaemon); t_runSourceDaemon.Start(); } else { RunSourceDaemon(); } break; //source default: Console.Error.WriteLine("Invalid Daemon Type."); break; } break; } break; //daemon case "Open": if (CommandParts.Length < 2) { Console.Error.WriteLine("Open requires at least one parameter: [async] Open <Repository Type>"); continue; } switch (CommandParts [1]) { case "LevelDB": if (CommandParts.Length < 4) { Console.Error.WriteLine("LevelDB repository requires at least two parameter: [async] Open File <Repository Nick> <Repository> <Path>"); continue; } if (CommandModifiers.Contains("async")) { System.Threading.Thread t_addrepo = new System.Threading.Thread(() => { OpenLevelDBRepository(CommandParts); }); t_addrepo.Start(); Console.WriteLine("[{0}]", t_addrepo.ManagedThreadId); } else { OpenLevelDBRepository(CommandParts); } break; //file case "Network": if (CommandParts.Length < 5) { Console.Error.WriteLine("Network repository requires at least three parameter: [async] Open File <Repository Nick> <Repository> <IPAddress> <Port>"); continue; } if (CommandModifiers.Contains("async")) { System.Threading.Thread t_addrepo = new System.Threading.Thread(() => { OpenNetworkRepository(CommandParts); }); t_addrepo.Start(); Console.WriteLine("[{0}]", t_addrepo.ManagedThreadId); } else { OpenNetworkRepository(CommandParts); } break; case "Socket": break; } break; case "Close": break; case "Execute": break; case "Convert": if (CommandParts.Length < 2) { Console.Error.WriteLine("Open requires at least one parameter: [async] Open <Repository Type> [Parameters]"); continue; } switch (CommandParts [1]) { case "Table": string daemonIPAddress = Query("Daemon IP Address"); string DaemonPort = Query("Daemon Port"); System.Net.IPAddress IPA = System.Net.IPAddress.Parse(daemonIPAddress); System.Net.IPEndPoint IPEP = new System.Net.IPEndPoint(IPA, int.Parse(DaemonPort)); System.Net.Sockets.TcpClient TC = new System.Net.Sockets.TcpClient(); TC.Connect(IPEP); System.Net.Sockets.NetworkStream NS = TC.GetStream(); BD2.Daemon.StreamHandler SH = new BD2.Daemon.StreamHandler(NS); BD2.Daemon.ObjectBus OB = new BD2.Daemon.ObjectBus(SH); BD2.Daemon.ServiceManager SM = new BD2.Daemon.ServiceManager(OB); SM.AnounceReady(); SM.WaitForRemoteReady(); Guid serviceType_SQL = Guid.Parse("57ce8883-1010-41ec-96da-41d36c64d65d"); var RS = SM.EnumerateRemoteServices(); BD2.Daemon.ServiceAnnounceMessage TSA = null; foreach (var SA in RS) { if (SA.Type == serviceType_SQL) { TSA = SA; } } if (TSA == null) { Console.WriteLine("Required services for Table Conversion not found on remote host."); } BD2.Daemon.TransparentAgent agent = (BD2.Daemon.TransparentAgent) SM.RequestService(TSA, (new BD2.Conv.Daemon.MSSQL.ServiceParameters(Query("Connection String"))).Serialize(), BD2.Daemon.TransparentAgent.CreateAgent, null); Client CL = new Client(agent, repositories [Query("Repository Name")], Query("Database Name")); CL.Convert(); break; } break; case "await": string jobID = commandparts [1]; int intJobID = int.Parse(jobID); jobs [intJobID].Join(); break; case "Exit": return; default: Console.Error.WriteLine(string.Format("{0} is not a valid command.", CommandParts [0])); break; } } while(true); }
public static IEnumerable <string> GetTrieTerms(this CrawledIssue issue) { var result = new SortedSet <string>(StringComparer.OrdinalIgnoreCase); AddTermsFromMarkdown(result, issue.Title); // TODO: Should we index the body or not? // AddTermsFromMarkdown(result, issue.Body); result.Add($"org:{issue.Repo.Org}"); result.Add($"repo:{issue.Repo.Name}"); result.Add($"repo:{issue.Repo.FullName}"); result.Add($"author:{issue.CreatedBy}"); foreach (var assignee in issue.Assignees) { result.Add($"assignee:{assignee}"); } foreach (var label in issue.Labels) { result.Add($"label:{label.Name}"); } foreach (var area in issue.Areas) { result.Add($"area-under:{area}"); } foreach (var areaNode in issue.AreaNodes) { result.Add($"area-node:{areaNode}"); } foreach (var areaLead in issue.AreaLeads) { result.Add($"area-lead:{areaLead}"); } foreach (var areaOwner in issue.AreaOwners) { result.Add($"area-owner:{areaOwner}"); } if (issue.Milestone is not null) { result.Add($"milestone:{issue.Milestone.Title}"); } return(result); }
static void Main(string[] args) { var @set = new SortedSet <Guid>(); var sw = Stopwatch.StartNew(); for (int i = 0; i < 2000000; i++) { var g = Guid.NewGuid(); sw.Start(); @set.Add(g); sw.Stop(); } var l = new List <Guid>(@set); var query = l.AsQueryable(); var query1 = l.AsQueryable(); //var sw1 = Stopwatch.StartNew(); //l.SortBy(n => n).ToList(); //sw1.Stop(); //var sw2 = Stopwatch.StartNew(); //l.AsParallel().SortBy(n => n).ToList(); //sw2.Stop(); var ss1 = Stopwatch.StartNew(); var dt1 = query.ToArray(); ss1.Stop(); var ss2 = Stopwatch.StartNew(); var dt2 = query1.AsParallel().ToArray(); ss2.Stop(); Console.ReadLine(); //var heapsortSorter = new HeapsortSorter<Guid>(); //var mergesortSorter = new MergesortSorter<Guid>(); //var quicksortSorter = new QuicksortSorter<Guid>(); //var quicksort3waySorter = new Quicksort3waySorter<Guid>(); //var quicksortIndexSorter = new QuicksortIndexSorter<Guid>(); //var rbTreeSorter = new RbTreeSorter<Guid>(); //var rbTreeIndexSorter = new RbTreeIndexSorter<Guid>(); //var sw1 = Stopwatch.StartNew(); //heapsortSorter.Sort(l, false); //sw1.Stop(); //var sw2 = Stopwatch.StartNew(); //mergesortSorter.Sort(l, false); //sw2.Stop(); //var sw3 = Stopwatch.StartNew(); //quicksortSorter.Sort(l, false); //sw3.Stop(); //var sw4 = Stopwatch.StartNew(); //quicksort3waySorter.Sort(l, false); //sw4.Stop(); //var sw5 = Stopwatch.StartNew(); //var dd = quicksortIndexSorter.Sort(l, false).GetEnumerator().MoveNext(); //sw5.Stop(); //var sw6 = Stopwatch.StartNew(); //rbTreeSorter.Sort(l, false); //sw6.Stop(); //var sw7 = Stopwatch.StartNew(); //rbTreeIndexSorter.Sort(l, false); //sw7.Stop(); }
public void GetUniqueDate() { personsData.ForEach(p => dates.Add(p.Date)); }
protected virtual void Graph_NewMarkedNode(DependencyNodeCore <NodeFactory> obj) { var eetypeNode = obj as EETypeNode; if (eetypeNode != null) { _typesWithEETypesGenerated.Add(eetypeNode.Type); if (eetypeNode is ConstructedEETypeNode || eetypeNode is CanonicalEETypeNode) { _typesWithConstructedEETypesGenerated.Add(eetypeNode.Type); } return; } IMethodBodyNode methodBodyNode = obj as IMethodBodyNode; if (methodBodyNode != null) { _methodBodiesGenerated.Add(methodBodyNode); } IMethodNode methodNode = methodBodyNode; if (methodNode != null) { if (AllMethodsCanBeReflectable) { _reflectableMethods.Add(methodNode.Method); } } if (methodNode == null) { methodNode = obj as ShadowConcreteMethodNode; } if (methodNode != null) { _methodsGenerated.Add(methodNode.Method); return; } var reflectableMethodNode = obj as ReflectableMethodNode; if (reflectableMethodNode != null) { _reflectableMethods.Add(reflectableMethodNode.Method); } var nonGcStaticSectionNode = obj as NonGCStaticsNode; if (nonGcStaticSectionNode != null && nonGcStaticSectionNode.HasCCtorContext) { _cctorContextsGenerated.Add(nonGcStaticSectionNode); } var gvmEntryNode = obj as TypeGVMEntriesNode; if (gvmEntryNode != null) { _typeGVMEntries.Add(gvmEntryNode); } var dictionaryNode = obj as GenericDictionaryNode; if (dictionaryNode != null) { _genericDictionariesGenerated.Add(dictionaryNode); if (dictionaryNode.OwningEntity is MethodDesc method && AllMethodsCanBeReflectable) { _reflectableMethods.Add(method); } } if (obj is StructMarshallingDataNode structMarshallingDataNode) { _typesWithStructMarshalling.Add(structMarshallingDataNode.Type); } if (obj is DelegateMarshallingDataNode delegateMarshallingDataNode) { _typesWithDelegateMarshalling.Add(delegateMarshallingDataNode.Type); } if (obj is DynamicInvokeTemplateNode dynamicInvokeTemplate) { _dynamicInvokeTemplates.Add(dynamicInvokeTemplate.Method); } if (obj is NativeLayoutTemplateMethodSignatureVertexNode templateMethodEntry) { _templateMethodEntries.Add(templateMethodEntry); } }
public static EtwManifest ParseWmiEventTraceClass(Guid provider) { // we make a best effort attempt to fit the metadata of this Legacy (MOF) provider into the instrumentation manifest format // we need to find the EventTrace class where the Guid class qualifier matches our provider Guid // afaik you can't query for qualifiers...just classes and properties. :-/ // so we loop through all of the EventTrace classes and compare var providerSearcher = new ManagementObjectSearcher("root\\WMI", $"SELECT * FROM meta_class WHERE __superclass = 'EventTrace'", null); ManagementClass providerClass = null; foreach (ManagementClass candidateProviderClass in providerSearcher.Get()) { foreach (QualifierData qd in candidateProviderClass.Qualifiers) { if (qd.Name.ToLower() == "guid" && new Guid((string)qd.Value) == provider) { providerClass = candidateProviderClass; break; // found } } if (providerClass != null) { break; // found } } if (providerClass == null) { throw new ApplicationException($"Provider {provider} has no corresponding EventTrace class in WMI Repository"); // not found } var manifest = new EtwManifest(string.Empty) { ProviderGuid = provider, ProviderSymbol = (string)providerClass["__CLASS"] }; var events = new SortedDictionary <string, EtwEvent>(); var templates = new List <EtwTemplate>(); var stringTable = new Dictionary <string, string>(); // the provider name is usually in the Description Qualifier for the EventTrace class (but not always?) // and the keywords are properties for the EventTrace class // but we can already get both of these easily from Microsoft.Diagnostics.Tracing manifest.ProviderName = TraceEventProviders.GetProviderName(provider); manifest.Keywords = TraceEventProviders.GetProviderKeywords(provider).Select(info => new EtwKeyword { Name = info.Name, Mask = info.Value, Message = info.Description }).ToArray(); // event details are in the grandchildren of the top-level (EventTrace) provider class // WMI EventTrace children ~ a versioned category grouping // WMI EventTrace grandchildren ~ instrumentation manifest templates // note - event version can be set on the category and/or the event var templateNames = new SortedSet <string>(); var taskSearcher = new ManagementObjectSearcher("root\\WMI", $"SELECT * FROM meta_class WHERE __superclass = '{providerClass["__CLASS"]}'", null); foreach (ManagementClass categoryVersionClass in taskSearcher.Get()) { var categoryVersion = 0; var category = string.Empty; var categoryDescription = string.Empty; var displayName = string.Empty; foreach (QualifierData qd in categoryVersionClass.Qualifiers) { if (qd.Value.GetType() == typeof(Int32) && qd.Name.ToLower() == "eventversion") { categoryVersion = (Int32)qd.Value; } else if (qd.Value.GetType() == typeof(String) && qd.Name.ToLower() == "guid") { category = (string)qd.Value; } else if (qd.Value.GetType() == typeof(String) && qd.Name.ToLower() == "description") { categoryDescription = (string)qd.Value; } else if (qd.Value.GetType() == typeof(String) && qd.Name.ToLower() == "displayname") { displayName = (string)qd.Value; } } var templateSearcher = new ManagementObjectSearcher("root\\WMI", $"SELECT * FROM meta_class WHERE __superclass = '{categoryVersionClass["__CLASS"]}'", null); foreach (ManagementClass templateClass in templateSearcher.Get()) { // EventTypeName qualifier ~ OpCode var template = (string)templateClass["__CLASS"]; var eventType = string.Empty; var version = categoryVersion; var description = categoryDescription; foreach (QualifierData qd in templateClass.Qualifiers) { if (qd.Value.GetType() == typeof(Int32) && qd.Name.ToLower() == "eventversion") { version = (Int32)qd.Value; // override category version with specific event version } else if (qd.Value.GetType() == typeof(String) && qd.Name.ToLower() == "eventtypename") { eventType = (string)qd.Value; } else if (qd.Value.GetType() == typeof(String) && qd.Name.ToLower() == "description") { description = (string)qd.Value; } } if (!string.IsNullOrEmpty(categoryDescription)) { stringTable.Add(template, categoryDescription); } // EventType -> id(s) var ids = new SortedSet <Int32>(); foreach (QualifierData qd in templateClass.Qualifiers) { if (qd.Name.ToLower() == "eventtype") { if (qd.Value.GetType() == typeof(Int32)) { ids.Add((Int32)qd.Value); } else if (qd.Value.GetType().IsArray) { foreach (var element in (Array)qd.Value) { if (element.GetType() == typeof(Int32)) { ids.Add((Int32)element); } } } break; } } // sort by category, id, version foreach (var id in ids) { events.Add($"{category}{id,6}{version,6}", new EtwEvent { Value = id, Symbol = template, Opcode = eventType, Version = version, Template = template, Keyword = description, Task = category }); } // create a template from the properties var templateData = new SortedDictionary <int, EtwTemplateData>(); foreach (PropertyData pd in templateClass.Properties) { foreach (QualifierData qd in pd.Qualifiers) { if (qd.Value.GetType() == typeof(Int32) && qd.Name.ToLower() == "wmidataid") { var id = (int)qd.Value; templateData[id] = new EtwTemplateData { Name = pd.Name, Type = pd.Type.ToString() }; break; } } } templates.Add(new EtwTemplate(template, templateData.Values.ToArray())); } } manifest.Events = events.Values.ToArray(); manifest.Templates = templates.ToArray(); manifest.StringTable = stringTable; return(manifest); }
public async Task <ImageCacherObject> GetImage(string[] tags, bool forceExplicit, DapiSearchType type, HashSet <string> blacklistedTags = null) { tags = tags.Select(tag => tag?.ToLowerInvariant()).ToArray(); blacklistedTags = blacklistedTags ?? new HashSet <string>(); foreach (var item in defaultTagBlacklist) { blacklistedTags.Add(item); } blacklistedTags = blacklistedTags.Select(t => t.ToLowerInvariant()).ToHashSet(); if (tags.Any(x => blacklistedTags.Contains(x))) { throw new Exception("One of the specified tags is blacklisted"); } if (type == DapiSearchType.E621) { tags = tags.Select(tag => tag?.Replace("yuri", "female/female", StringComparison.InvariantCulture)) .ToArray(); } await _lock.WaitAsync().ConfigureAwait(false); try { ImageCacherObject[] imgs; if (tags.Any()) { imgs = _cache.Where(x => x.Tags.IsSupersetOf(tags) && x.SearchType == type && (!forceExplicit || x.Rating == "e")).ToArray(); } else { imgs = _cache.Where(x => x.SearchType == type).ToArray(); } imgs = imgs.Where(x => x.Tags.All(t => !blacklistedTags.Contains(t.ToLowerInvariant()))).ToArray(); ImageCacherObject img; if (imgs.Length == 0) { img = null; } else { img = imgs[_rng.Next(imgs.Length)]; } if (img != null) { _cache.Remove(img); return(img); } else { var images = await DownloadImagesAsync(tags, forceExplicit, type).ConfigureAwait(false); images = images .Where(x => x.Tags.All(t => !blacklistedTags.Contains(t.ToLowerInvariant()))) .ToArray(); if (images.Length == 0) { return(null); } var toReturn = images[_rng.Next(images.Length)]; foreach (var dledImg in images) { if (dledImg != toReturn) { _cache.Add(dledImg); } } return(toReturn); } } finally { _lock.Release(); } }
public void AddGameCellToTable(int x, int y, bool color = true) { table.Add(new GameCell(FormatX(x), FormatY(y), color)); }
public void Solve() { SortedSet <Troop> mockTroops = mission.factory.incoming; List <Troop> finalEnlisted = new List <Troop>(); Factory factory = mission.factory; foreach (var mockTestTroop in mission.acceptedMission) { mockTroops.Add(mockTestTroop); finalEnlisted.Add(mockTestTroop); FactoryState lastState = new FactoryState(factory, Game.gameTime); bool allyLock = factory.isAlly; int armyAvailable = allyLock ? factory.count : 0; var ordered = mockTroops.ToList(); //iterate through the mock states for (int i = 0; i < ordered.Count; i++) { Troop troop = ordered[i]; FactoryState newState = new FactoryState(lastState, troop); //if two troops arrives at the same time if (i + 1 < ordered.Count && troop.endTime == ordered[i + 1].endTime) { lastState = newState; continue; } if (allyLock && newState.isEnemy) { allyLock = false; break; } if (allyLock == false && newState.isAlly) { allyLock = true; armyAvailable = newState.count; } if (factory.isAlly && troop == mockTestTroop) { armyAvailable = newState.count; } armyAvailable = Math.Min(armyAvailable, newState.count); lastState = newState; } if (allyLock) //mission is possible { mockTestTroop.count = Math.Max(1, mockTestTroop.count - armyAvailable + 1); //don't oversend foreach (Troop troop in finalEnlisted) { Action newAction = new Action(MoveType.Move, troop.start, troop.end, troop.count); Action.AddAction(newAction, troop); } return; } } }
bool UpdateChanges() { // Get the current status of the build int MaxChanges; int OldestChangeNumber = -1; int NewestChangeNumber = -1; HashSet <int> CurrentChangelists; SortedSet <int> PrevPromotedChangelists; lock (this) { MaxChanges = PendingMaxChanges; if (Changes.Count > 0) { NewestChangeNumber = Changes.First().Number; OldestChangeNumber = Changes.Last().Number; } CurrentChangelists = new HashSet <int>(Changes.Select(x => x.Number)); PrevPromotedChangelists = new SortedSet <int>(PromotedChangeNumbers); } // Build a full list of all the paths to sync List <string> DepotPaths = new List <string>(); if (SelectedClientFileName.EndsWith(".uprojectdirs", StringComparison.InvariantCultureIgnoreCase)) { DepotPaths.Add(String.Format("{0}/...", BranchClientPath)); } else { DepotPaths.Add(String.Format("{0}/*", BranchClientPath)); DepotPaths.Add(String.Format("{0}/Engine/...", BranchClientPath)); DepotPaths.Add(String.Format("{0}/...", PerforceUtils.GetClientOrDepotDirectoryName(SelectedClientFileName))); if (bIsEnterpriseProject) { DepotPaths.Add(String.Format("{0}/Enterprise/...", BranchClientPath)); } } // Read any new changes List <PerforceChangeSummary> NewChanges; if (MaxChanges > CurrentMaxChanges) { if (!Perforce.FindChanges(DepotPaths, MaxChanges, out NewChanges, LogWriter)) { return(false); } } else { if (!Perforce.FindChanges(DepotPaths.Select(DepotPath => String.Format("{0}@>{1}", DepotPath, NewestChangeNumber)), -1, out NewChanges, LogWriter)) { return(false); } } // Remove anything we already have NewChanges.RemoveAll(x => CurrentChangelists.Contains(x.Number)); // Update the change ranges if (NewChanges.Count > 0) { OldestChangeNumber = Math.Max(OldestChangeNumber, NewChanges.Last().Number); NewestChangeNumber = Math.Min(NewestChangeNumber, NewChanges.First().Number); } // If we are using zipped binaries, make sure we have every change since the last zip containing them. This is necessary for ensuring that content changes show as // syncable in the workspace view if there have been a large number of content changes since the last code change. int MinZippedChangeNumber = -1; foreach (int ChangeNumber in ChangeNumberToZippedBinaries.Keys) { if (ChangeNumber > MinZippedChangeNumber && ChangeNumber <= OldestChangeNumber) { MinZippedChangeNumber = ChangeNumber; } } if (MinZippedChangeNumber != -1 && MinZippedChangeNumber < OldestChangeNumber) { List <PerforceChangeSummary> ZipChanges; if (Perforce.FindChanges(DepotPaths.Select(DepotPath => String.Format("{0}@{1},{2}", DepotPath, MinZippedChangeNumber, OldestChangeNumber - 1)), -1, out ZipChanges, LogWriter)) { NewChanges.AddRange(ZipChanges); } } // Fixup any ROBOMERGE authors const string RoboMergePrefix = "#ROBOMERGE-AUTHOR:"; foreach (PerforceChangeSummary Change in NewChanges) { if (Change.Description.StartsWith(RoboMergePrefix)) { int StartIdx = RoboMergePrefix.Length; while (StartIdx < Change.Description.Length && Change.Description[StartIdx] == ' ') { StartIdx++; } int EndIdx = StartIdx; while (EndIdx < Change.Description.Length && !Char.IsWhiteSpace(Change.Description[EndIdx])) { EndIdx++; } if (EndIdx > StartIdx) { Change.User = Change.Description.Substring(StartIdx, EndIdx - StartIdx); Change.Description = "ROBOMERGE: " + Change.Description.Substring(EndIdx).TrimStart(); } } } // Process the new changes received if (NewChanges.Count > 0 || MaxChanges < CurrentMaxChanges) { // Insert them into the builds list lock (this) { Changes.UnionWith(NewChanges); if (Changes.Count > MaxChanges) { // Remove changes to shrink it to the max requested size, being careful to avoid removing changes that would affect our ability to correctly // show the availability for content changes using zipped binaries. SortedSet <PerforceChangeSummary> TrimmedChanges = new SortedSet <PerforceChangeSummary>(new PerforceChangeSorter()); foreach (PerforceChangeSummary Change in Changes) { TrimmedChanges.Add(Change); if (TrimmedChanges.Count >= MaxChanges && (ChangeNumberToZippedBinaries.Count == 0 || ChangeNumberToZippedBinaries.ContainsKey(Change.Number) || ChangeNumberToZippedBinaries.First().Key > Change.Number)) { break; } } Changes = TrimmedChanges; } CurrentMaxChanges = MaxChanges; } // Find the last submitted change by the current user int NewLastChangeByCurrentUser = -1; foreach (PerforceChangeSummary Change in Changes) { if (String.Compare(Change.User, Perforce.UserName, StringComparison.InvariantCultureIgnoreCase) == 0) { NewLastChangeByCurrentUser = Math.Max(NewLastChangeByCurrentUser, Change.Number); } } LastChangeByCurrentUser = NewLastChangeByCurrentUser; // Notify the main window that we've got more data if (OnUpdate != null) { OnUpdate(); } } return(true); }
/// <summary> /// Check intersection between each triangles. /// </summary> /// <param name="trianglesPoints">Each three points are coordinates for triangle. (trianglesPoints.Count % 3 must equals 0)</param> /// <returns>Return true if some triangles intersect</returns> public static bool TrianglesIntersection(List <Vector2> trianglesPoints) { if (trianglesPoints == null) { throw new ArgumentNullException("trianglesPoints can't be null"); } if (trianglesPoints.Count % 3 != 0) { throw new ArgumentException("trianglesPoints.Count % 3 must equals 0"); } //prepare. Put each triangle into bounding rectangle. List <BRectangle> bRectangle = new List <BRectangle>(trianglesPoints.Count / 3); for (int i = 0; i < trianglesPoints.Count; i += 3) { Vector2 min = trianglesPoints[i]; Vector2 max = trianglesPoints[i]; for (int j = 1; j < 3; j++) { min.X = Math.Min(min.X, trianglesPoints[i + j].X); min.Y = Math.Min(min.Y, trianglesPoints[i + j].Y); max.X = Math.Max(max.X, trianglesPoints[i + j].X); max.Y = Math.Max(max.Y, trianglesPoints[i + j].Y); } bRectangle.Add(new BRectangle(min, max, i / 3)); } List <BPoint2D> points = new List <BPoint2D>(bRectangle.Count * 2); //Create event-point(start, end) for each bounding rectangle bRectangle.ForEach(t => { points.Add(t.min); points.Add(t.max); }); //Sort event-point points.Sort((a, b) => { if (a.pos.X < b.pos.X) { return(-1); } else if (a.pos.X > b.pos.X) { return(1); } else { if (a.isStart == b.isStart) { return(0); } if (!a.isStart) { return(-1); } if (!b.isStart) { return(1); } return(0); } }); //Use scan line for OX. SortedSet <BRectangle> rectangles = new SortedSet <BRectangle>(Comparer <BRectangle> .Create((a, b) => { if (a.id == b.id) { return(0); } else { if (a.min.pos.Y.CompareTo(b.min.pos.Y) <= 0) { return(-1); } else { return(1); } } })); for (int i = 0; i < points.Count; i++) // O(N) { BRectangle temp = bRectangle[points[i].id]; //if event is start, we should check our rectangle with each rectangle in SortedSet if (points[i].isStart) { foreach (var r in rectangles) { if (r.min.pos.Y > temp.max.pos.Y) { break; } if (temp.min.pos.Y <= r.max.pos.Y && temp.min.pos.Y >= r.min.pos.Y || temp.max.pos.Y <= r.max.pos.Y && temp.max.pos.Y >= r.min.pos.Y) { List <Vector2> firstTriangle = new List <Vector2>() { trianglesPoints[temp.id * 3], trianglesPoints[temp.id * 3 + 1], trianglesPoints[temp.id * 3 + 2] }; List <Vector2> secondTriangle = new List <Vector2>() { trianglesPoints[r.id * 3], trianglesPoints[r.id * 3 + 1], trianglesPoints[r.id * 3 + 2] }; //Call private function. The first triangle must be greater. if ((temp.max.pos.X - temp.min.pos.X) > (r.max.pos.X - r.min.pos.X)) { if (TriangleIntersection(firstTriangle, secondTriangle)) { return(true); } } else { if (TriangleIntersection(secondTriangle, firstTriangle)) { return(true); } } } } //Don't forget to put rectangle. rectangles.Add(temp); } else { //End event. Delete rectangle from sorted set. rectangles.Remove(temp); } } return(false); }
//find path for moving and return it MGPumMoveCommand findPath(MGPumField field, MGPumUnit unit) { // can we find this out in a better way? queued = new bool[8, 8]; tilesToVisit = new SortedSet <Vector2Int>(new AStarComparer(field.coords)); predecessors = new Dictionary <Vector2Int, Vector2Int>(); //distance = new Dictionary<Vector2Int, int>(); tilesToVisit.Add(unit.field.coords); queued[unit.field.coords.x, unit.field.coords.y] = true; int recursion = 0; int maxRecursion = 500; while (tilesToVisit.Count > 0) { recursion++; if (recursion > maxRecursion) { break; } Vector2Int position = tilesToVisit.Min; tilesToVisit.Remove(position); if (!state.fields.inBounds(position)) { continue; } //touchedTiles.Add(position); if (position == field.coords) { List <Vector2Int> path = new List <Vector2Int>(); path.Add(position); //reconstruct path in reverse while (predecessors.ContainsKey(path[0])) { path.Insert(0, predecessors[path[0]]); } MGPumMoveChainMatcher matcher = unit.getMoveMatcher(); MGPumFieldChain chain = new MGPumFieldChain(unit.ownerID, matcher); for (int i = 0; i < path.Count; i++) { chain.add(state.getField(path[i])); } if (chain.isValidChain()) { MGPumMoveCommand mc = new MGPumMoveCommand(this.playerID, chain, unit); return(mc); } continue; } foreach (Vector2Int direction in getDirections()) { Vector2Int neighbor = position + direction; if (!state.fields.inBounds(neighbor)) { continue; } if (!queued[neighbor.x, neighbor.y] && state.getUnitForField(state.getField(neighbor)) == null) { queued[neighbor.x, neighbor.y] = true; tilesToVisit.Add(neighbor); predecessors.Add(neighbor, position); //distance.Add(neighbor, ) } } } return(null); }
private void AcquireLock(string resource) { _lockedResources.Add($"{_storage.SchemaName}:{resource}:Lock"); }
public EmployerSearchModel ToEmployerSearchResult(bool keyOnly = false, List <SicCodeSearchModel> listOfSicCodeSearchModels = null) { if (keyOnly) { return(new EmployerSearchModel { OrganisationId = OrganisationId.ToString() }); } // Get the last two names for the org. Most recent name first string[] names = OrganisationNames.Select(n => n.Name).Reverse().Take(2).ToArray(); var abbreviations = new SortedSet <string>(StringComparer.OrdinalIgnoreCase); names.ForEach(n => abbreviations.Add(n.ToAbbr())); names.ForEach(n => abbreviations.Add(n.ToAbbr("."))); var excludes = new[] { "Ltd", "Limited", "PLC", "Corporation", "Incorporated", "LLP", "The", "And", "&", "For", "Of", "To" }; names.ForEach(n => abbreviations.Add(n.ToAbbr(excludeWords: excludes))); names.ForEach(n => abbreviations.Add(n.ToAbbr(".", excludeWords: excludes))); abbreviations.RemoveWhere(a => string.IsNullOrWhiteSpace(a)); abbreviations.Remove(OrganisationName); // extract the prev org name (if exists) var prevOrganisationName = ""; if (names.Length > 1) { prevOrganisationName = names[names.Length - 1]; abbreviations.Remove(prevOrganisationName); } //Get the latest sic codes IEnumerable <OrganisationSicCode> sicCodes = GetSicCodes(); Return[] submittedReports = GetSubmittedReports().ToArray(); var result = new EmployerSearchModel { OrganisationId = OrganisationId.ToString(), OrganisationIdEncrypted = GetEncryptedId(), Name = OrganisationName, PreviousName = prevOrganisationName, PartialNameForSuffixSearches = OrganisationName, PartialNameForCompleteTokenSearches = OrganisationName, Abbreviations = abbreviations.ToArray(), Size = GetLatestReturn() == null ? 0 : (int)GetLatestReturn().OrganisationSize, SicSectionIds = sicCodes.Select(sic => sic.SicCode.SicSectionId.ToString()).Distinct().ToArray(), SicSectionNames = sicCodes.Select(sic => sic.SicCode.SicSection.Description).Distinct().ToArray(), SicCodeIds = sicCodes.Select(sicCode => sicCode.SicCodeId.ToString()).Distinct().ToArray(), Address = GetLatestAddress()?.GetAddressString(), LatestReportedDate = submittedReports.Select(x => x.Created).FirstOrDefault(), ReportedYears = submittedReports.Select(x => x.AccountingDate.Year.ToString()).ToArray(), ReportedLateYears = submittedReports.Where(x => x.IsLateSubmission).Select(x => x.AccountingDate.Year.ToString()).ToArray(), ReportedExplanationYears = submittedReports.Where(x => string.IsNullOrEmpty(x.CompanyLinkToGPGInfo) == false) .Select(x => x.AccountingDate.Year.ToString()) .ToArray() }; if (listOfSicCodeSearchModels != null) { result.SicCodeListOfSynonyms = GetListOfSynonyms(result.SicCodeIds, listOfSicCodeSearchModels); } return(result); }
public void Add(Item item) { itemSet.Add(item); }
public void TestExploreAllInterleavings() { SortedSet <string> results = new SortedSet <string>(); string success = "Explored interleavings."; this.TestWithError(async(runtime) => { InMemoryLogger log = new InMemoryLogger(); Task task1 = Task.Run(async() => { log.WriteLine(">foo"); await Task.Delay(runtime.RandomInteger(10)); log.WriteLine("<foo"); }); Task task2 = Task.Run(async() => { log.WriteLine(">bar"); await Task.Delay(runtime.RandomInteger(10)); log.WriteLine("<bar"); }); await Task.WhenAll(task1, task2); results.Add(log.ToString()); Specification.Assert(results.Count < 6, success); }, configuration: GetConfiguration().WithTestingIterations(1000), expectedError: success); string expected = @">bar <bar >foo <foo >bar >foo <bar <foo >bar >foo <foo <bar >foo <foo >bar <bar >foo >bar <bar <foo >foo >bar <foo <bar "; expected = expected.NormalizeNewLines(); string actual = string.Join("\n", results).NormalizeNewLines(); Assert.Equal(expected, actual); }
// ---------------------------------------------- // Search API // ---------------------------------------------- /// <inheritdoc /> protected override IEnumerable <UPath> EnumeratePathsImpl(UPath path, string searchPattern, SearchOption searchOption, SearchTarget searchTarget) { var search = SearchPattern.Parse(ref path, ref searchPattern); var directoryToVisit = new List <UPath>(); directoryToVisit.Add(path); var entries = new SortedSet <UPath>(UPath.DefaultComparerIgnoreCase); var sortedDirectories = new SortedSet <UPath>(UPath.DefaultComparerIgnoreCase); var fileSystems = new List <IFileSystem>(); if (NextFileSystem != null) { fileSystems.Add(NextFileSystem); } // Query all filesystems just once lock (_fileSystems) { fileSystems.AddRange(_fileSystems); } while (directoryToVisit.Count > 0) { var pathToVisit = directoryToVisit[0]; directoryToVisit.RemoveAt(0); int dirIndex = 0; entries.Clear(); sortedDirectories.Clear(); for (var i = fileSystems.Count - 1; i >= 0; i--) { var fileSystem = fileSystems[i]; if (fileSystem.DirectoryExists(pathToVisit)) { foreach (var item in fileSystem.EnumeratePaths(pathToVisit, "*", SearchOption.TopDirectoryOnly, SearchTarget.Both)) { if (!entries.Contains(item)) { var isFile = fileSystem.FileExists(item); var isDirectory = fileSystem.DirectoryExists(item); var isMatching = search.Match(item); if (isMatching && ((isFile && searchTarget != SearchTarget.Directory) || (isDirectory && searchTarget != SearchTarget.File))) { entries.Add(item); } if (searchOption == SearchOption.AllDirectories && isDirectory) { sortedDirectories.Add(item); } } } } } // Enqueue directories and respect order foreach (var nextDir in sortedDirectories) { directoryToVisit.Insert(dirIndex++, nextDir); } // Return entries foreach (var entry in entries) { yield return(entry); } } }
private static void BuildBetweenDfa <T>(ref Automaat <State <T> > a, SortedSet <Tuple <T, char, SortedSet <T> > > table, ref int stateCounter, State <T> s) where T : IComparable { foreach (var symbol in a._symbols) { var toStates = new SortedSet <T>(); foreach (var state in s.States) { foreach (var record in table) { if (record.Item1.CompareTo(state) == 0 && record.Item2 == symbol) { record.Item3.ToList().ForEach(toState => toStates.Add(toState)); } } } var transToState = s; var stateId = stateCounter; var stateExsists = false; if (toStates.Count == 0) { stateId = 0; foreach (var state in a._states) { if (state.Id == stateId) { stateExsists = true; transToState = state; break; } } } else { var isSameState = false; foreach (var state in a._states) { isSameState = state.HasSameStates(toStates); if (isSameState) { stateExsists = true; transToState = state; break; } } if (!isSameState) { stateCounter++; stateId = stateCounter; } } if (!stateExsists) { var newState = new State <T>(stateId) { States = toStates }; a.AddTransition(new Transition <State <T> >(s, symbol, newState)); BuildBetweenDfa(ref a, table, ref stateCounter, newState); } else { a.AddTransition(new Transition <State <T> >(s, symbol, transToState)); } } }
public bool AddSegment(Segment s) { return(_segmentSet.Add(s)); }
protected internal override void AddFontStream(PdfDictionary fontDescriptor) { if (embedded) { PdfName fontFileName; PdfStream fontStream; if (fontProgram is IDocFontProgram) { fontFileName = ((IDocFontProgram)fontProgram).GetFontFileName(); fontStream = ((IDocFontProgram)fontProgram).GetFontFile(); } else { if (((TrueTypeFont)GetFontProgram()).IsCff()) { fontFileName = PdfName.FontFile3; try { byte[] fontStreamBytes = ((TrueTypeFont)GetFontProgram()).GetFontStreamBytes(); fontStream = GetPdfFontStream(fontStreamBytes, new int[] { fontStreamBytes.Length }); fontStream.Put(PdfName.Subtype, new PdfName("Type1C")); } catch (PdfException e) { ILog logger = LogManager.GetLogger(typeof(iText.Kernel.Font.PdfTrueTypeFont)); logger.Error(e.Message); fontStream = null; } } else { fontFileName = PdfName.FontFile2; SortedSet <int> glyphs = new SortedSet <int>(); for (int k = 0; k < shortTag.Length; k++) { if (shortTag[k] != 0) { int uni = fontEncoding.GetUnicode(k); Glyph glyph = uni > -1 ? fontProgram.GetGlyph(uni) : fontProgram.GetGlyphByCode(k); if (glyph != null) { glyphs.Add(glyph.GetCode()); } } } ((TrueTypeFont)GetFontProgram()).UpdateUsedGlyphs(glyphs, subset, subsetRanges); try { byte[] fontStreamBytes; //getDirectoryOffset() > 0 means ttc, which shall be subset anyway. if (subset || ((TrueTypeFont)GetFontProgram()).GetDirectoryOffset() > 0) { fontStreamBytes = ((TrueTypeFont)GetFontProgram()).GetSubset(glyphs, subset); } else { fontStreamBytes = ((TrueTypeFont)GetFontProgram()).GetFontStreamBytes(); } fontStream = GetPdfFontStream(fontStreamBytes, new int[] { fontStreamBytes.Length }); } catch (PdfException e) { ILog logger = LogManager.GetLogger(typeof(iText.Kernel.Font.PdfTrueTypeFont)); logger.Error(e.Message); fontStream = null; } } } if (fontStream != null) { fontDescriptor.Put(fontFileName, fontStream); if (fontStream.GetIndirectReference() != null) { fontStream.Flush(); } } } }
public static string CheckSolution() { SortedSet <int> nodesVisited1 = new SortedSet <int>(); int currentNode = 0; bool feasible = true; do { if (nodesVisited1.Contains(currentNode)) { return(String.Format("not feasible: Node {0} is visited twice in solution 1", currentNode)); } nodesVisited1.Add(currentNode); int nextNode = _route1[currentNode].Next; if (_route2[currentNode].Prev == nextNode || _route2[currentNode].Next == nextNode) { Console.WriteLine(String.Format("not feasible: Arc from node {0} to node {1} is in both solutions", currentNode, nextNode)); feasible = false; } currentNode = _route1[currentNode].Next; } while (currentNode != 0); if (nodesVisited1.Count != _route1.Count) { Console.WriteLine(String.Format("not feasible: The following nodes are not visited in solution 1: ")); for (int node = 0; node < _route1.Count; node++) { if (!nodesVisited1.Contains(node)) { Console.WriteLine(String.Format("{0}", node)); } } feasible = false; } SortedSet <int> nodesVisited2 = new SortedSet <int>(); currentNode = 0; do { if (nodesVisited2.Contains(currentNode)) { return(String.Format("not feasible: Node {0} is visited twice in solution 2", currentNode)); } nodesVisited2.Add(currentNode); currentNode = _route2[currentNode].Next; } while (currentNode != 0); if (nodesVisited2.Count != _route2.Count) { Console.WriteLine(String.Format("not feasible: The following nodes are not visited in solution 3: ")); for (int node = 0; node < _route2.Count; node++) { if (!nodesVisited2.Contains(node)) { Console.WriteLine(String.Format("{0}", node)); } } feasible = false; } return(String.Format("Is Solution Feasible? {0}", feasible)); }
public void AddClipboardObject(ClipboardObject clipboardObject) { clipboardObjects.Add(clipboardObject); }
public SegmentMesh(ColorTemplate template) { int numGroups = template.NumSlots(); imageWidth = template.Width(); imageHeight = template.Height(); groups = new List <SegmentGroup>(); segments = new List <Segment>(); //now populate the segments and segment groups //filter out groups that have no members (due to quantization) Dictionary <int, int> slotToGroup = new Dictionary <int, int>(); for (int i = 0; i < numGroups; i++) { if (template.PixelsInSlot(i) > 0) { slotToGroup.Add(i, groups.Count()); groups.Add(new SegmentGroup(template.OriginalSlotColor(i))); } } UnionFind <Color> uf = new UnionFind <Color>((a, b) => (a.GetHashCode() == b.GetHashCode())); Bitmap image = template.DebugQuantization(); assignments = uf.ConnectedComponentsNoiseRemoval(Util.BitmapToArray(image)); Dictionary <int, Segment> idToSegment = new Dictionary <int, Segment>(); int totalAdjacencyPerimeter = 0; Dictionary <int, HashSet <Point> > idToPerimeter = new Dictionary <int, HashSet <Point> >(); //populate segments int width = image.Width; int height = image.Height; for (int i = 0; i < width; i++) { for (int j = 0; j < height; j++) { int id = assignments[i, j]; if (!idToSegment.ContainsKey(id)) { idToSegment.Add(id, new Segment(id)); idToPerimeter.Add(id, new HashSet <Point>()); } idToSegment[id].points.Add(new Point(i, j)); idToSegment[id].groupId = slotToGroup[template.GetSlotId(i, j)]; //look for 8-neighbor adjacencies, 2 pixels away //TODO: measure adjacency strength and filter? for (int dx = -2; dx <= 2; dx++) { for (int dy = -2; dy <= 2; dy++) { int x = i + dx; int y = j + dy; if (x >= 0 && x < width && y >= 0 && y < height) { int nid = assignments[x, y]; if (nid != id) { idToSegment[id].adjacencies.Add(nid); //keep track of the total perimeter, and individual segment perimeters //don't double count the same point for each segment if (!idToPerimeter[id].Contains(new Point(x, y))) { idToPerimeter[id].Add(new Point(x, y)); totalAdjacencyPerimeter++; //keep track of the adjacecy strength per segment if (!idToSegment[id].adjacencyStrength.ContainsKey(nid)) { idToSegment[id].adjacencyStrength.Add(nid, 0); } idToSegment[id].adjacencyStrength[nid]++; } else { Console.WriteLine("Point already counted"); } } } else { //might as well be consistent here, and take into account the borders of the image when determining //enclosure. We don't need to do this for the totalAdjacencyPerimeter, because that is just a normalization //for the adjacency strengths of segments within the image if (!idToPerimeter[id].Contains(new Point(x, y))) { idToPerimeter[id].Add(new Point(x, y)); } } } } } } //finalize segment list and adjacency list Dictionary <int, int> idToIdx = new Dictionary <int, int>(); foreach (int id in idToSegment.Keys) { segments.Add(idToSegment[id]); idToIdx.Add(id, segments.Count() - 1); } //finalize adjacencies for (int i = 0; i < segments.Count(); i++) { SortedSet <int> renamedAdj = new SortedSet <int>(); foreach (int a in segments[i].adjacencies) { renamedAdj.Add(idToIdx[a]); } segments[i].adjacencies = renamedAdj; //finalize adjacency strengths int sid = assignments[segments[i].points.First().X, segments[i].points.First().Y]; Dictionary <int, double> renamedAdjStrength = new Dictionary <int, double>(); foreach (int nid in segments[i].adjacencyStrength.Keys) { double pixelsAdj = segments[i].adjacencyStrength[nid]; renamedAdjStrength.Add(idToIdx[nid], pixelsAdj / totalAdjacencyPerimeter); segments[i].enclosureStrength.Add(idToIdx[nid], new Tuple <double, double>(pixelsAdj / idToPerimeter[sid].Count(), pixelsAdj / idToPerimeter[nid].Count())); } segments[i].adjacencyStrength = renamedAdjStrength; } //finalize groups for (int i = 0; i < segments.Count(); i++) { int groupId = segments[i].groupId; groups[groupId].members.Add(i); } //finalize segment list ClassifySegments(); foreach (Segment s in segments) { ComputeFeatures(s); } foreach (SegmentGroup g in groups) { ComputeFeatures(g); } }
static ReqResult Req(Task task, int len) { Counter++; if (Counter > CounterMax || len >= BestScore) { return(new ReqResult() { Value = BestScore, AllowCash = false }); } if (task.Path.Length <= 3) { if (len < BestScore) { BestScore = len; } return(new ReqResult()); } if (cash.ContainsKey(task.Hash)) { var cashv = cash[task.Hash]; if (cashv + len < BestScore) { BestScore = cashv + len; } return(new ReqResult() { Value = cashv }); } var vertexes = new SortedSet <Task>(); var isSkiped = false; for (int i = 0; i < task.Path.Length; i++) { var vert = task.Path[i]; var prev = task.Path[i == 0 ? task.Path.Length - 1 : i - 1]; var next = task.Path[i == task.Path.Length - 1 ? 0 : i + 1]; var cutValue = Matrix[prev, next]; if (len + cutValue >= BestScore) { isSkiped = true; continue; } var newpath = new int[task.Path.Length - 1]; Array.Copy(task.Path, 0, newpath, 0, i); Array.Copy(task.Path, i + 1, newpath, i, task.Path.Length - i - 1); var value = cutValue; for (int j = 0; j < task.Path.Length; j++) { var curv = task.Path[j]; if (curv != vert && curv != prev && curv != next) { value -= Matrix[vert, curv]; } if (Counter > CounterMax) { return(new ReqResult() { Value = BestScore, AllowCash = false }); } } vertexes.Add(new Task(value, newpath) { CutValue = cutValue }); } var result = Int32.MaxValue; var allowCash = false; foreach (var vertex in vertexes) { var r = Req(vertex, len + vertex.CutValue); var rv = r.Value == int.MaxValue ? int.MaxValue : r.Value + vertex.CutValue; if (result > rv) { result = rv; allowCash = r.AllowCash; } else if (result == rv && r.AllowCash) { allowCash = r.AllowCash; } if (Counter > CounterMax) { return(new ReqResult() { Value = BestScore, AllowCash = false }); } } allowCash = allowCash && !isSkiped; if (allowCash) { cash[task.Hash] = result; } return(new ReqResult() { Value = result, AllowCash = allowCash }); }
public static int Dijkstra2() { var Pipe = new SortedSet <Task2>(); var path = new int[N]; for (int i = 0; i < N; i++) { path[i] = i; } Pipe.Add(new Task2(0, new int[][] { path })); while (Pipe.Count > 0) { var task = Pipe.Min; Pipe.Remove(task); if (task.Parts.Length == 0) { BestScore = task.Value; return(task.Value); } if (cash.ContainsKey(task.Hash)) { continue; } cash[task.Hash] = task.Value; for (int i = 0; i < task.Parts.Length; i++) { path = task.Parts[i]; for (int j = 0; j < path.Length - 2; j++) { for (int k = j + 2; k < path.Length; k++) { var leftpart = (j + 1) + (path.Length - k) > 3; var rightpart = k - j + 1 > 3; var newparts = new int[task.Parts.Length - 1 + (leftpart ? 1 : 0) + (rightpart ? 1 : 0)][]; Array.Copy(task.Parts, 0, newparts, 0, i); if (leftpart) { var newpath = new int[(j + 1) + (path.Length - k)]; Array.Copy(path, 0, newpath, 0, j + 1); Array.Copy(path, k, newpath, j + 1, path.Length - k); newparts[i] = newpath; } if (rightpart) { var newpath = new int[k - j + 1]; Array.Copy(path, j, newpath, 0, newpath.Length); newparts[i + (leftpart ? 1 : 0)] = newpath; } Array.Copy(task.Parts, i + 1, newparts, i + (leftpart ? 1 : 0) + (rightpart ? 1 : 0), task.Parts.Length - i - 1); var value = task.Value + Matrix[path[j], path[k]]; var newtask = new Task2(value, newparts); if (cash.ContainsKey(newtask.Hash)) { continue; } Pipe.Add(newtask); } } } } return(BestScore); }