コード例 #1
0
        public void OnNext(long value)
        {
            // should be done with locking
            if (!_queue.Any())
            {
                CurrentTick++;
                return;
            }

            var first = _queue.GetFirst();

            while (_queue.Any() && (first.NextStateTick <= CurrentTick))
            {
                RemoveObjectFromQueue(first);
                var result = first.Act();

                if (!result)
                {
                    AddObjectToQueue(first);
                }

                if (_queue.Any())
                {
                    first = _queue.GetFirst();
                }
            }

            CurrentTick++;
        }
コード例 #2
0
        public int Solve(int k, int[] cookies)
        {
            var priorityQueue = new OrderedBag <int>();

            foreach (var cookie in cookies)
            {
                priorityQueue.Add(cookie);
            }

            int currentMinSweetness = priorityQueue.GetFirst();
            int steps = 0;

            while (currentMinSweetness < k && priorityQueue.Count > 1)
            {
                int leastSweetCookie       = priorityQueue.RemoveFirst();
                int secondLeastSweetCookie = priorityQueue.RemoveFirst();

                int combined = leastSweetCookie + (2 * secondLeastSweetCookie);

                priorityQueue.Add(combined);

                currentMinSweetness = priorityQueue.GetFirst();
                steps++;
            }

            return(currentMinSweetness < k ? -1 : steps);
        }
コード例 #3
0
        public void OnNext(long value)
        {
            // should be done with locking
            if (!_queue.Any())
            {
                CurrentTick++;
                return;
            }

            // todo maybe write use tasks here
            var first = _queue.GetFirst();

            while (_queue.Any() && (first.NextStateTick <= CurrentTick))
            {
                if (first.CurrentState == null || !first.CurrentState.Eternal)
                {
                    RemoveObjectFromQueue(first);
                    first.NextState();
                }

                /* else
                 * {
                 *   first.NextStateTick += 1;
                 * }*/

                first = _queue.GetFirst();
            }

            CurrentTick++;
        }
コード例 #4
0
    public T Dequeue()
    {
        var element = bag.GetFirst();

        bag.RemoveFirst();
        return(element);
    }
コード例 #5
0
        public int Solve(int k, int[] cookies)
        {
            OrderedBag <int> bag = new OrderedBag <int>();

            foreach (var cookie in cookies)
            {
                bag.Add(cookie);
            }

            int currentMinSweetness = bag.GetFirst();
            int operationsCount     = 0;

            while (currentMinSweetness < k && bag.Count > 1)
            {
                int leastSweetCookie       = bag.RemoveFirst();
                int secondLeastSweetCookie = bag.RemoveFirst();

                int combined = leastSweetCookie + (2 * secondLeastSweetCookie);

                bag.Add(combined);

                currentMinSweetness = bag.GetFirst();
                operationsCount++;
            }

            return(currentMinSweetness < k ? -1 : operationsCount);
        }
コード例 #6
0
        public int Solve(int k, int[] cookies)
        {
            var bag = new OrderedBag <int>();

            foreach (var cookie in cookies)
            {
                bag.Add(cookie);
            }

            int steps        = 0;
            int minSweetness = bag.GetFirst();

            while (minSweetness < k && bag.Count > 1)
            {
                int firstSweet  = bag.RemoveFirst();
                int secondSweet = bag.RemoveFirst();

                int sweetness = firstSweet + (2 * secondSweet);
                bag.Add(sweetness);

                minSweetness = bag.GetFirst();
                steps++;
            }

            return(minSweetness < k ? -1 : steps);
        }
コード例 #7
0
        public int Solve(int k, int[] cookies)
        {
            OrderedBag <int> orderedCookies = new OrderedBag <int>();

            foreach (var cookie in cookies)
            {
                orderedCookies.Add(cookie);
            }

            int operations    = 0;
            int currentCookie = orderedCookies.GetFirst();

            while (currentCookie < k)
            {
                if (orderedCookies.Count <= 1)
                {
                    return(-1);
                }
                else
                {
                    currentCookie = orderedCookies.RemoveFirst() + (2 * orderedCookies.RemoveFirst());
                    orderedCookies.Add(currentCookie);
                    operations++;
                    currentCookie = orderedCookies.GetFirst();
                }
            }

            return(operations);
        }
コード例 #8
0
        public int Solve(int k, int[] cookies)
        {
            var priorityQueue = new OrderedBag <int>();

            foreach (var cookie in cookies)
            {
                priorityQueue.Add(cookie);
            }

            int count = 0;
            int currLeastSweetCookie = priorityQueue.GetFirst();

            while (currLeastSweetCookie < k && priorityQueue.Count > 1)
            {
                int firstLeastSweet  = priorityQueue.RemoveFirst();
                int secondLeastSweet = priorityQueue.RemoveFirst();

                int combined = firstLeastSweet + 2 * secondLeastSweet;
                priorityQueue.Add(combined);

                currLeastSweetCookie = priorityQueue.GetFirst();
                count++;
            }

            return(currLeastSweetCookie < k ? -1 : count);
        }
コード例 #9
0
        public int Solve(int k, int[] cookies)
        {
            var bag = new OrderedBag <int>();

            foreach (var cookie in cookies)
            {
                bag.Add(cookie);
            }

            var currMinSweetCookie = bag.GetFirst();
            int steps = 0;

            while (currMinSweetCookie < k && bag.Count > 1)
            {
                var minSweetCookie       = bag.RemoveFirst();
                var beforeMinSweetCookie = bag.RemoveFirst();

                var newCookie = minSweetCookie + (2 * beforeMinSweetCookie);

                bag.Add(newCookie);

                currMinSweetCookie = bag.GetFirst();
                steps++;
            }

            return(currMinSweetCookie < k ? -1 : steps);
        }
コード例 #10
0
        private void decrease_process_level()
        {
            OrderedBag <int>          fringe_top  = d_fringe.Pop();
            MaxTreeNode <ElementType> popped_node = pop_component_stack();

            if (fringe_top.Count == 0) // if the popped fringe is empty
            {
                if (d_component_stack.Count == 0)
                {
                    d_bottom_level_node = popped_node; // we are done.
                }
                else
                {
                    // and add the new node to there
                    d_component_stack.Peek().Item3.Add(popped_node);
                }
            }
            else
            // if the popped fringe is not empty
            {
                if (d_component_stack.Count == 0)
                {
                    // find where tocontinue
                    ElementType next_process_level = d_element_array[fringe_top.GetFirst()];
                    d_fringe.Push(fringe_top); // push the fringe back in
                    d_component_stack.Push(new Tuple <ElementType, IList <int>, IList <MaxTreeNode <ElementType> > >(next_process_level, new List <int>(),
                                                                                                                     new List <MaxTreeNode <ElementType> >()));
                    // add the popped node as child
                    d_component_stack.Peek().Item3.Add(popped_node);
                }
                else
                {
                    ElementType fringe_level          = d_element_array[fringe_top.GetFirst()];
                    ElementType component_stack_level = d_component_stack.Peek().Item1;
                    if (element_value_comparer.Compare(component_stack_level, fringe_level) == -1) //TODO
                    {
                        d_fringe.Push(fringe_top);                                                 // push the fringe back in
                        d_component_stack.Push(new Tuple <ElementType, IList <int>, IList <MaxTreeNode <ElementType> > >(fringe_level, new List <int>(),
                                                                                                                         new List <MaxTreeNode <ElementType> >()));
                        // add the popped node as child
                        d_component_stack.Peek().Item3.Add(popped_node);
                    }
                    else
                    {
                        while (0 < fringe_top.Count)
                        {
                            d_fringe.Peek().Add(fringe_top.RemoveFirst());
                        }
                        d_component_stack.Peek().Item3.Add(popped_node);
                    }
                }
            }
        }
コード例 #11
0
        public int Solve(int k, int[] cookies)
        {
            var numOperations = 0;
            var bag           = new OrderedBag <int>(cookies);

            while (bag.Count > 1)
            {
                var first  = bag.RemoveFirst();
                var second = 0;

                if (bag.Count > 0)
                {
                    second = bag.RemoveFirst();
                }

                var sum = first + (2 * second);
                bag.Add(sum);
                numOperations++;

                if (bag.GetFirst() >= k)
                {
                    return(numOperations);
                }
            }

            return(-1);
        }
コード例 #12
0
        private static List <Edge> Prim(int node)
        {
            List <Edge> spanningTree = new List <Edge>();

            spanningTreeNodes.Add(node);
            OrderedBag <Edge> prioriryQueue = new OrderedBag <Edge>(nodesByEdges[node]);

            while (prioriryQueue.Count > 0)
            {
                Edge edge = prioriryQueue.GetFirst();
                prioriryQueue.RemoveFirst();
                int nextNode = -1;

                if (spanningTreeNodes.Contains(edge.StartNode) && !spanningTreeNodes.Contains(edge.EndNode))
                {
                    nextNode = edge.EndNode;
                }

                if (spanningTreeNodes.Contains(edge.EndNode) && !spanningTreeNodes.Contains(edge.StartNode))
                {
                    nextNode = edge.StartNode;
                }

                if (nextNode == -1)
                {
                    continue;
                }

                spanningTree.Add(edge);
                spanningTreeNodes.Add(nextNode);
                prioriryQueue.AddMany(nodesByEdges[nextNode]);
            }

            return(spanningTree);
        }
コード例 #13
0
 public IEntity PeekMostRecent()
 {
     if (Size == 0)
     {
         throw new InvalidOperationException("Operation on empty Data");
     }
     return(data.GetFirst());
 }
コード例 #14
0
 private void SetCutOff(DateTime value)
 {
     _cutOff = value;
     while (_summaries.Count > 0 && _summaries.GetFirst().Timestamp < _cutOff)
     {
         _summaries.RemoveFirst();
     }
 }
コード例 #15
0
    public static void Main(string[] args)
    {
        Console.WriteLine("Please the number of paths in the network:");
        int numberOfPaths = int.Parse(Console.ReadLine());

        OrderedBag <Edge>              edges       = new OrderedBag <Edge>();
        Dictionary <int, Node>         nodes       = new Dictionary <int, Node>();
        Dictionary <int, List <Node> > parentNodes = new Dictionary <int, List <Node> >();

        for (int i = 0; i < numberOfPaths; i++)
        {
            int[] pathData = ReadUserInput();
            edges.Add(new Edge(pathData[0], pathData[1], pathData[2]));

            if (!nodes.ContainsKey(pathData[0]))
            {
                nodes[pathData[0]] = new Node(pathData[0], pathData[0]);
                parentNodes.Add(pathData[0], new List <Node> {
                    nodes[pathData[0]]
                });
            }

            if (!nodes.ContainsKey(pathData[1]))
            {
                nodes[pathData[1]] = new Node(pathData[1], pathData[1]);
                parentNodes.Add(pathData[1], new List <Node> {
                    nodes[pathData[1]]
                });
            }
        }

        List <NewEdge> minimalSpanningTreeEdges = new List <NewEdge>();

        while (parentNodes.Count > 1)
        {
            Edge currentEdge = edges.GetFirst();
            edges.RemoveFirst();

            int firstNodeId  = currentEdge.FirstNodeId;
            int secondNodeId = currentEdge.SecondNodeId;

            Node firstNode  = nodes[firstNodeId];
            Node secondNode = nodes[secondNodeId];

            if (firstNode.ParentId != secondNode.ParentId)
            {
                firstNode.Neighbors.Add(secondNode);
                secondNode.Neighbors.Add(firstNode);
                SetTreeParentId(firstNode.ParentId, secondNode.ParentId, parentNodes);
                minimalSpanningTreeEdges.Add(new NewEdge(firstNode, secondNode, currentEdge.Distance));
            }
        }

        Console.WriteLine("The resulting minimal spanning tree is:");
        PrintTreeEdges(minimalSpanningTreeEdges);
    }
コード例 #16
0
        static void Main()
        {
            var strs = Console.ReadLine().Split(' ');
            var n    = int.Parse(strs[0]);
            var k    = int.Parse(strs[1]);

            if (n < k)
            {
                Console.WriteLine(0);
                return;
            }

            strs = Console.ReadLine().Split(' ');
            var f = long.Parse(strs[0]);
            var a = int.Parse(strs[1]);
            var b = int.Parse(strs[2]);
            var m = int.Parse(strs[3]);

            var set    = new OrderedBag <long>();
            var result = new long[k];

            result[0] = (int)f;

            set.Add(f);
            for (int i = 1; i < k; ++i)
            {
                f         = (f * a + b) % m;
                result[i] = f;
                set.Add(f);
            }

            for (int i = k; i < n; ++i)
            {
                f = (f * a + b) % m;

                var cell = set.GetFirst() + f;
                set.Add(cell);
                set.Remove(result[i % k]);
                result[i % k] = cell;
            }

            Console.WriteLine(set.GetFirst());
        }
コード例 #17
0
ファイル: StartUp.cs プロジェクト: MeGaDeTH91/SoftUni
        public static void Prim(int startNode, int damage)
        {
            var queue = new OrderedBag <Edge>();

            HashSet <int>          spanningTree = new HashSet <int>();
            Dictionary <int, long> currentDmgs  = new Dictionary <int, long>();

            currentDmgs[startNode] = damage;
            damages[startNode]    += damage;
            spanningTree.Add(startNode);
            queue.AddMany(graph[startNode]);

            while (queue.Count > 0)
            {
                var minEdge = queue.GetFirst();
                queue.RemoveFirst();

                int firstNode  = minEdge.StartNode;
                int secondNode = minEdge.EndNode;

                int treeNode    = -1;
                int nonTreeNode = -1;

                if (spanningTree.Contains(firstNode) &&
                    !spanningTree.Contains(secondNode))
                {
                    treeNode    = firstNode;
                    nonTreeNode = secondNode;
                }
                else if (spanningTree.Contains(secondNode) &&
                         !spanningTree.Contains(firstNode))
                {
                    treeNode    = secondNode;
                    nonTreeNode = firstNode;
                }
                else if (nonTreeNode == -1)
                {
                    continue;
                }

                spanningTree.Add(nonTreeNode);
                if (!currentDmgs.ContainsKey(nonTreeNode))
                {
                    currentDmgs[nonTreeNode] = 0;
                }
                currentDmgs[nonTreeNode] = currentDmgs[treeNode] / 2;
                damages[nonTreeNode]    += currentDmgs[nonTreeNode];
                queue.AddMany(graph[nonTreeNode]);
                //if (currentDmgs[nonTreeNode] == 0)
                //{
                //    break;
                //}
            }
        }
コード例 #18
0
ファイル: Program.cs プロジェクト: dpetrova/Algorithms
        static void Prim(int startingNode)
        {
            visitedNodes.Add(startingNode);

            var priorityQueue =
                new OrderedBag <Edge>(Comparer <Edge> .Create((first, second) => first.Weight - second.Weight));

            //get child edges of starting node
            var startingNodeChildEdges = childEdges[startingNode];

            //add child edges to priority queue
            priorityQueue.AddMany(startingNodeChildEdges);

            //while priority queue is not empty
            while (priorityQueue.Count > 0)
            {
                //get min edge by weight
                var minEdge = priorityQueue.GetFirst();
                priorityQueue.Remove(minEdge);

                //check if minEdge will cause cycle
                //to not cause a cycle one node must be in tree, the other not
                var first       = minEdge.FirstNode;
                var second      = minEdge.SecondNode;
                var nonTreeNode = -1;

                if (visitedNodes.Contains(first) && !visitedNodes.Contains(second))
                {
                    nonTreeNode = second;
                }

                if (visitedNodes.Contains(second) && !visitedNodes.Contains(first))
                {
                    nonTreeNode = first;
                }

                if (nonTreeNode == -1)
                {
                    continue;                    //both nodes are in visited -> cause cycle
                }
                //add edge to spanning tree
                spanningTree.Add(minEdge);
                //print edge
                Console.WriteLine($"{minEdge.FirstNode} - {minEdge.SecondNode}");

                visitedNodes.Add(nonTreeNode);

                //enqueue all child nodes of nonTreeNode to priority queue
                priorityQueue.AddMany(childEdges[nonTreeNode]);
            }
        }
コード例 #19
0
        public int Solve(int k, int[] cookies)
        {
            var prioritySweetness = new OrderedBag <int>();

            foreach (var sweetness in cookies)
            {
                prioritySweetness.Add(sweetness);
            }

            int currentCookie = prioritySweetness.GetFirst();
            int operations    = 0;

            while (currentCookie < k && prioritySweetness.Count > 1)
            {
                int firstCookie    = prioritySweetness.RemoveFirst();
                int secondCookie   = prioritySweetness.RemoveFirst();
                int combinedCookie = firstCookie + (2 * secondCookie);
                prioritySweetness.Add(combinedCookie);
                currentCookie = prioritySweetness.GetFirst();
                operations++;
            }
            return(currentCookie >= k ? operations : -1);
        }
コード例 #20
0
        public int Solve(int k, int[] cookies)
        {
            var bag = new OrderedBag <int>();

            foreach (var cookie in cookies)
            {
                bag.Add(cookie);
            }
            int currentCookie = bag.GetFirst();
            int count         = 0;

            while (currentCookie < k &&
                   bag.Count > 1)
            {
                int firstCookie  = bag.RemoveFirst();
                int secondCookie = bag.RemoveFirst();
                int combined     = firstCookie + 2 * secondCookie;
                bag.Add(combined);
                currentCookie = bag.GetFirst();
                count++;
            }
            return(currentCookie < k ? -1 : count);
        }
        public int Solve(int k, int[] cookies)
        {
            var priorityQueque = new OrderedBag <int>(
                // CompairElelemts
                );

            foreach (var cookie in cookies)
            {
                priorityQueque.Add(cookie);
            }

            int currentMinSweetness = priorityQueque.GetFirst();
            int steps = 0;

            while (currentMinSweetness < k && priorityQueque.Count > 1)
            {
                int leastSweetCookie       = priorityQueque.RemoveFirst();
                int secondLeastSweetCookie = priorityQueque.RemoveFirst();

                int combined = leastSweetCookie + (2 * secondLeastSweetCookie);
                priorityQueque.Add(combined);

                currentMinSweetness = priorityQueque.GetFirst();
                steps++;
            }

            return(currentMinSweetness < k ? -1 : steps);

            // Descending
            int CompairElelemts(int first, int second)
            {
                return(second - first);
            }

            //if Object implement
        }
コード例 #22
0
        public int Solve(int k, int[] cookies)
        {
            var count        = 0;
            var bagOfCookies = new OrderedBag <int>(cookies);

            while (bagOfCookies.Count > 1)
            {
                if (bagOfCookies.GetFirst() > k)
                {
                    return(count);
                }
                count++;
                var first  = bagOfCookies.RemoveFirst();
                var second = bagOfCookies.RemoveFirst();
                bagOfCookies.Add(first + 2 * second);
            }

            if (bagOfCookies.GetFirst() > k)
            {
                return(count);
            }

            return(-1);
        }
コード例 #23
0
ファイル: Loss.cs プロジェクト: omaremadeldin/fastText.Net
        protected void DFS(
            int k,
            float threshold,
            int node,
            float score,
            Predictions predictions,
            float[] hidden)
        {
            var heap = new OrderedBag <Tuple <float, int> >(
                predictions,
                new Comparison <Tuple <float, int> >((l, r) =>
            {
                var b = l.Item1 > r.Item1;
                return(b ? 1 : 0);
            }));

            if (score < StdLog(threshold))
            {
                return;
            }

            if (heap.Count == k && score < heap.GetFirst().Item1)
            {
                return;
            }

            if (tree_[node].left == -1 && tree_[node].right == -1)
            {
                heap.Add(Tuple.Create(score, node));

                if (heap.Count > k)
                {
                    heap.RemoveFirst();
                }

                return;
            }

            var f = wo_.DotRow(hidden, node - osz_);

            f = 1f / (1 + (float)Math.Exp(-f));

            predictions = heap.ToList();

            DFS(k, threshold, tree_[node].left, score + StdLog(1f - f), predictions, hidden);
            DFS(k, threshold, tree_[node].right, score + StdLog(f), predictions, hidden);
        }
コード例 #24
0
        public static void PrintShortestPathLegth(Graph graph, char startNode, char goalNode)
        {
            int length = 1;
            OrderedBag <Edge> openEdges = new OrderedBag <Edge>();
            char currentNode            = startNode;

            bool[] visitedEdges = new bool[graph.Edges.Count];
            for (int index = 0; index < graph.Edges.Count; index++)
            {
                if ((graph.Edges[index].EdgeNodeOne == currentNode) || (graph.Edges[index].EdgeNodeTwo == currentNode))
                {
                    Edge temp = graph.Edges[index];
                    visitedEdges[index] = true;
                    temp.length         = length;
                    openEdges.Add(temp);
                }
            }

            while (openEdges.Count != 0)
            {
                Edge currentEdge = openEdges.GetFirst();
                char nextNode    = currentEdge.EdgeNodeTwo;
                openEdges.RemoveFirst();
                if (currentEdge.EdgeNodeOne == goalNode || currentEdge.EdgeNodeTwo == goalNode)
                {
                    Console.WriteLine(currentEdge.length);
                    return;
                }

                length = currentEdge.length + 1;
                for (int index = 0; index < graph.Edges.Count; index++)
                {
                    if (!visitedEdges[index])
                    {
                        if ((graph.Edges[index].EdgeNodeOne == nextNode) || (graph.Edges[index].EdgeNodeTwo == nextNode))
                        {
                            Edge temp = graph.Edges[index];
                            visitedEdges[index] = true;
                            temp.length         = length;
                            openEdges.Add(temp);
                        }
                    }
                }
            }
        }
コード例 #25
0
        static void Main()
        {
            var strs = Console.ReadLine().Split(' ');
            var n    = int.Parse(strs[0]);
            var m    = int.Parse(strs[1]);
            var l    = int.Parse(strs[2]);

            var intervals = new Tuple <int, int> [n];

            for (int i = 0; i < n; ++i)
            {
                strs         = Console.ReadLine().Split(' ');
                intervals[i] = new Tuple <int, int>(
                    int.Parse(strs[0]),
                    int.Parse(strs[1]));
            }
            Array.Sort(intervals);

            var result  = 0;
            var boarded = new OrderedBag <int>();

            foreach (var x in intervals)
            {
                while (boarded.Count > 0)
                {
                    var firstItem = boarded.GetFirst();
                    if (firstItem > x.Item1)
                    {
                        break;
                    }
                    boarded.RemoveFirst();
                    ++result;
                }
                boarded.Add(x.Item2);
                if (boarded.Count > m)
                {
                    boarded.RemoveLast();
                }
            }

            result += boarded.Count;
            Console.WriteLine(result);
        }
コード例 #26
0
        static void Prim(int startingNode)
        {
            spanningTree.Add(startingNode);

            var prioriryQueue = new OrderedBag <Edge>(Comparer <Edge> .Create((f, s) => f.Weight - s.Weight));

            prioriryQueue.AddMany(nodeToEdges[startingNode]);

            while (prioriryQueue.Count != 0)
            {
                var minEdge = prioriryQueue.GetFirst();
                prioriryQueue.Remove(minEdge);

                var firstNode  = minEdge.First;
                var secondNode = minEdge.Second;

                var nonTreeNode = -1;

                if (spanningTree.Contains(firstNode) &&
                    !spanningTree.Contains(secondNode))
                {
                    nonTreeNode = secondNode;
                }

                if (spanningTree.Contains(secondNode) &&
                    !spanningTree.Contains(firstNode))
                {
                    nonTreeNode = firstNode;
                }

                if (nonTreeNode == -1)
                {
                    continue;
                }

                spanningTree.Add(nonTreeNode);

                Console.WriteLine($"{minEdge.First} - {minEdge.Second}");

                prioriryQueue.AddMany(nodeToEdges[nonTreeNode]);
            }
        }
コード例 #27
0
    private static long GetShortestDistanceToHospital(Node hospital, Graph graph, Dictionary <int, Node> hospitals)
    {
        graph.InitGraphDijkstraDistances();

        OrderedBag <Node> nextDijksrtaNode = new OrderedBag <Node>();
        Set <Node>        visited          = new Set <Node>();

        hospital.DijkstraDistance = 0;
        nextDijksrtaNode.Add(hospital);

        while (nextDijksrtaNode.Count > 0)
        {
            Node currentNode = nextDijksrtaNode.GetFirst();
            nextDijksrtaNode.RemoveFirst();
            visited.Add(currentNode);

            foreach (Connection connection in graph.NodeConnections[currentNode])
            {
                Node targetNode          = connection.TargetNode;
                int  newDijkstraDistance = currentNode.DijkstraDistance + connection.Distance;

                if (newDijkstraDistance < targetNode.DijkstraDistance)
                {
                    targetNode.DijkstraDistance = newDijkstraDistance;
                    nextDijksrtaNode.Add(targetNode);
                }
            }
        }

        long totalDistanceHomes = 0;

        foreach (Node visitedNode in visited)
        {
            if (!hospitals.ContainsKey(visitedNode.Id))
            {
                totalDistanceHomes += visitedNode.DijkstraDistance;
            }
        }

        return(totalDistanceHomes);
    }
コード例 #28
0
        private static void Prim(int startingNode)
        {
            visited.Add(startingNode);

            var priorityQueue = new OrderedBag <Edge>(
                Comparer <Edge> .Create((f, s) => f.Weight - s.Weight));

            priorityQueue.AddMany(graph[startingNode]);

            while (priorityQueue.Any())
            {
                var minEdge = priorityQueue.GetFirst();
                priorityQueue.Remove(minEdge);

                // Connect a non-tree node to the spanning tree, avoiding a cycle
                var nonTreeNode = -1;

                if (visited.Contains(minEdge.Start) &&
                    !visited.Contains(minEdge.End))
                {
                    nonTreeNode = minEdge.End;
                }

                if (!visited.Contains(minEdge.Start) &&
                    visited.Contains(minEdge.End))
                {
                    nonTreeNode = minEdge.Start;
                }

                if (nonTreeNode == -1)
                {
                    continue;
                }

                // Connect non-tree node & spanning tree
                minSpanningTree.Add(minEdge);

                visited.Add(nonTreeNode);
                priorityQueue.AddMany(graph[nonTreeNode]);
            }
        }
コード例 #29
0
        public static void Main()
        {
            var line = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
            int n    = line[0];
            int m    = line[1];

            var orderedBag = new OrderedBag <int>();

            var tickets = new Interval[n];

            for (int i = 0; i < n; i++)
            {
                var passengerInfo = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();

                tickets[i] = new Interval(passengerInfo[0], passengerInfo[1]);
            }

            Array.Sort(tickets, (a, b) => a.Start.CompareTo(b.Start));

            var selectedTickets = new OrderedBag <int>();
            int result          = 0;

            foreach (var ticket in tickets)
            {
                while (selectedTickets.Count > 0 && selectedTickets.GetFirst() <= ticket.Start)
                {
                    selectedTickets.RemoveFirst();
                    result++;
                }

                selectedTickets.Add(ticket.End);
                if (selectedTickets.Count > m)
                {
                    selectedTickets.RemoveLast();
                }
            }

            result += selectedTickets.Count;
            Console.WriteLine(result);
        }
コード例 #30
0
ファイル: solution.cs プロジェクト: snetww/judge-solved
        static void Main(string[] args)
        {
            var strs = Console.ReadLine().Split( );
            var n    = int.Parse(strs[0]);
            var m    = int.Parse(strs[1]);
            //var l = int.Parse(strs[2]);

            var tickets = new Tuple <int, int> [n];

            for (int i = 0; i < n; ++i)
            {
                strs       = Console.ReadLine().Split( );
                tickets[i] = new Tuple <int, int>(
                    int.Parse(strs[0]),
                    int.Parse(strs[1]));
            }

            Array.Sort(tickets);

            var selectedTickets = new OrderedBag <int>();
            var result          = n;

            foreach (var ticket in tickets)
            {
                while (selectedTickets.Count > 0 && selectedTickets.GetFirst() <= ticket.Item1)
                {
                    selectedTickets.RemoveFirst();
                }

                selectedTickets.Add(ticket.Item2);
                if (selectedTickets.Count > m)
                {
                    selectedTickets.RemoveLast();
                    --result;
                }
            }

            //result += selectedTickets.Count;
            Console.WriteLine(result);
        }
コード例 #31
0
        /// <summary>
        /// AStar - Performs the A* algorithm search to find a
        ///         solution of a given BoardNode.
        /// </summary>
        /// <param name="root">BoardNode to find a solution for</param>
        /// <returns>BoardNode containing the solution. NULL if no solution found</returns>
        public static BoardNode AStar(BoardNode root)
        {
            BoardNode current = root;
            Comparison<BoardNode> compare = new Comparison<BoardNode>(compareFScore);
            OrderedBag<BoardNode> openList = new OrderedBag<BoardNode>(compare);
            OrderedBag<BoardNode> closedList = new OrderedBag<BoardNode>(compare);
            int curGScore;
            int heuristic;

            curGScore = 0;
            heuristic = current.board.numRemainingLights();
            current.gScore = curGScore;
            current.fScore = (curGScore + heuristic);

            openList.Add(current);

            while(openList.Count != 0)
            {
                current = openList.GetFirst();

                if(current.clicked.Capacity >= 100000)
                {
                    return null;
                }

                if(current.board.solved())
                {
                    return current;
                }

                openList.Remove(current);
                closedList.Add(current);

                addChildren(current);

                foreach (BoardNode child in current.children)
                {
                    if (closedList.Contains(child))
                    {
                        ;
                    }
                    else
                    {
                        curGScore = current.gScore + 1;

                        if (openList.Contains(child) == false || curGScore < child.gScore)
                        {
                            child.gScore = (curGScore);
                            heuristic = child.board.numRemainingLights();
                            child.fScore = (curGScore + heuristic);

                            if (openList.Contains(child) == false)
                            {
                                openList.Add(child);
                            }
                        }
                    }
                }
            }

            return null;
        }