Exemplo n.º 1
0
        /// <summary>
        /// Dijkstra algorithm (longest path) based on graph g for start vertice s. Positive cycles are NOT allowed in longest path algorithm
        /// </summary>
        /// <param name="g">Graph for search</param>
        /// <param name="s">Start vertice</param>
        public static PathStats LongestPath(GraphBase g, int s)
        {
            var ps = new PathStats(g.V);

            for (var i = 0; i < ps.Dist.Length; i++)
            {
                ps.Dist[i] = int.MinValue;
                ps.Prev[i] = -1;
            }

            ps.Dist[s] = 0;//start vertice
            var pq = new IndexMaxPQ<Distance>(ps.Dist.Length);
            for (int i = 0; i < ps.Dist.Length; i++)
            {
                pq.Insert(i, new Distance { V = i, Dist = ps.Dist[i] });
            }

            while (!pq.IsEmpty())
            {
                var v = pq.DelRoot();

                foreach (var e in g.Adjacent(v))
                {
                    if (ps.Dist[e.V2] < ps.Dist[v] + e.Weight)   //longest path
                    {
                        ps.Dist[e.V2] = ps.Dist[v] + e.Weight;
                        ps.Prev[e.V2] = v;
                        pq.ChangeKey(e.V2, new Distance { V = e.V2, Dist = ps.Dist[e.V2] });
                    }
                }
            }

            return ps;
        }
Exemplo n.º 2
0
 public void Initialize()
 {
     _target = new IndexMaxPQ<Distance>(4);
     _target.Insert(2, new Distance { V = 2, Dist = 1 });
     _target.Insert(1, new Distance { V = 1, Dist = 3 });
     _target.Insert(0, new Distance { V = 0, Dist = 2 });
 }
 public void EnumeratorMaxPQTest()
 {
     // Expected: same as sorting the input and inserting it in a regular queue
      Queue<string> expectedItems = new Queue<string>(this.testStrings.OrderByDescending(s => s));
      IndexMaxPQ<string> pq = new IndexMaxPQ<string>(this.testStrings.Length);
      CommonIndexPQUnitTests.EnumerationPQTest(this.testStrings, pq, expectedItems);
 }
        public void IndexedMaxPQIncreaseKeyTest()
        {
            // arrange
            var pq = new IndexMaxPQ <string>(array);

            // act + assert initial
            Assert.False(pq.IsEmpty);
            Assert.Equal(10, pq.Size);
            Assert.Equal(9, pq.Index);
            Assert.Equal(9, pq.MaxIndex);
            Assert.Equal("worst", pq.Max);
            Assert.Equal("worst", pq.TopKey);

            // act + assert ex
            try
            {
                pq.increaseKey(9, "exception");
            }
            catch (Exception ex)
            {
                Assert.IsType <ArgumentException>(ex);
                Assert.Equal("Calling increaseKey() with given argument would not strictly increase the key", ex.Message);
            }

            // act + assert increase
            pq.increaseKey(9, "worst even");
            Assert.Equal("worst even", pq.Max);
            Assert.Equal("worst even", pq.TopKey);
        }
        public void IndexMaxPQIteratorTest()
        {
            var pq     = new IndexMaxPQ <String>(array);
            var actual = Strings(pq).ToList();

            Assert.Equal(indexedMax, actual);
        }
 public void Merge3WayMaxPQTest()
 {
     string[] inputFiles = { "Algs4-Data\\m1r.txt", "Algs4-Data\\m2r.txt", "Algs4-Data\\m3r.txt" };
      Queue<string> expectedItems = new Queue<string>(
     "A B C F G I I Z B D H P Q Q A B E F J N".Split(" ".ToCharArray()).OrderByDescending(s => s));
      IndexMaxPQ<string> pq = new IndexMaxPQ<string>(expectedItems.Count);
      CommonIndexPQUnitTests.MergeMultiWay(inputFiles, pq, expectedItems);
 }
Exemplo n.º 7
0
        public void Run()
        {
            Console.WriteLine("Choose file:");   // Prompt
            Console.WriteLine("1 - tinyPQ.txt"); // Prompt
            Console.WriteLine("or quit");        // Prompt

            var fileNumber = Console.ReadLine();
            var fieName    = string.Empty;

            switch (fileNumber)
            {
            case "1":
                fieName = "tinyIndexPQ.txt";
                break;

            case "quit":
                return;

            default:
                return;
            }


            var @in   = new In($"Files\\Sorting\\{fieName}");
            var words = @in.ReadAllStrings();

            //var list = words.Select(word => new StringComparable(word)).ToList();

            //var listComparable = list.Cast<IComparable>().ToList();
            //var arrayComparable = list.Cast<IComparable>().ToArray();
            var listStrings = words.ToList();


            var pq = new IndexMaxPQ <string>(listStrings.Count);

            //Fill Priority Queue
            for (var i = 0; i < listStrings.Count; i++)
            {
                pq.Insert(i, listStrings[i]);
            }
            // print results
            foreach (var item in pq)
            {
                Console.WriteLine(pq.KeyOf(item));
            }


            Console.ReadLine();
        }
Exemplo n.º 8
0
        public void IndexMaxPQTest1()
        {
            const int    MaxSize  = 8;
            const double MinValue = 3.9;
            const double MaxValue = MinValue * MaxSize + 32;
            int          index;

            // MaxValue index == 3, MinValue index == 4
            double[] items = { MinValue * 2, MinValue * 3, MinValue * 4, MaxValue, MinValue, MinValue * 5, MinValue * 6, MinValue * 7 };
            StdRandom.Seed = 101;

            IndexMaxPQ <double> pq = new IndexMaxPQ <double>(MaxSize);

            index = StdRandom.Uniform(items.Length);
            Assert.IsFalse(pq.Contains(index));
            Assert.IsTrue(pq.IsEmpty);
            Assert.AreEqual(0, pq.Count);

            try
            {
                index = pq.DelMax();
                Assert.Fail("Failed to catch exception");
            }
            catch (InvalidOperationException) { }

            for (int i = 0; i < items.Length; i++)
            {
                pq.Insert(i, items[i]);
            }
            Assert.AreEqual(items.Length, pq.Count);
            Assert.AreEqual(MaxValue, pq.MaxKey);
            Assert.AreEqual(3, pq.MaxIndex);
            Assert.AreEqual(MinValue, pq.KeyOf(4));

            index = StdRandom.Uniform(items.Length);
            Assert.AreEqual(items[index], pq.KeyOf(index));

            pq.ChangeKey(1, pq.MaxKey * 1.9); // make it the largest item
            Assert.AreEqual(1, pq.MaxIndex);

            pq.IncreaseKey(3, pq.MaxKey * 1.87);
            Assert.AreEqual(3, pq.MaxIndex);

            pq.Delete(3);
            Assert.AreNotEqual(3, pq.MaxIndex);

            Assert.AreEqual(1, pq.DelMax());
        }
        public void IndexPQDeleteAtIndexTest()
        {
            var pq = new IndexMaxPQ <String>(array);

            Assert.True(pq.Contains(5));
            pq.Delete(5);
            Assert.False(pq.Contains(5));

            try
            {
                pq.Delete(5);
            }
            catch (Exception ex)
            {
                Assert.IsType <InvalidOperationException>(ex);
                Assert.Equal("index is not in the priority queue", ex.Message);
            }
        }
Exemplo n.º 10
0
        public void Run()
        {
            Console.WriteLine("Choose file:"); // Prompt
            Console.WriteLine("1 - tinyPQ.txt"); // Prompt
            Console.WriteLine("or quit"); // Prompt

            var fileNumber = Console.ReadLine();
            var fieName = string.Empty;
            switch (fileNumber)
            {
                case "1":
                    fieName = "tinyIndexPQ.txt";
                    break;
                case "quit":
                    return;
                default:
                    return;
            }

            var @in = new In($"Files\\Sorting\\{fieName}");
            var words = @in.ReadAllStrings();

            //var list = words.Select(word => new StringComparable(word)).ToList();

            //var listComparable = list.Cast<IComparable>().ToList();
            //var arrayComparable = list.Cast<IComparable>().ToArray();
            var listStrings = words.ToList();

            var pq = new IndexMaxPQ<string>(listStrings.Count);
            //Fill Priority Queue
            for (var i = 0; i < listStrings.Count; i++)
            {
                 pq.Insert(i, listStrings[i]);

            }
            // print results
            foreach (var item in pq)
            {
                Console.WriteLine(pq.KeyOf(item));
            }

            Console.ReadLine();
        }
Exemplo n.º 11
0
 /**
  * Returns the cut-of-the-phase. The cut-of-the-phase is a minimum s-t-cut
  * in the current graph, where {@code s} and {@code t} are the two vertices
  * added last in the phase. This algorithm is known in the literature as
  * <em>maximum adjacency search</em> or <em>maximum cardinality search</em>.
  * 
  * @param G the edge-weighted graph
  * @param marked the array of contracted vertices, where {@code marked[v]}
  *            is {@code true} if the vertex {@code v} was already
  *            contracted; or {@code false} otherwise
  * @param cp the previous cut-of-the-phase
  * @return the cut-of-the-phase
  */
 private CutPhase minCutPhase(EdgeWeightedGraph G, boolean[] marked, CutPhase cp) {
     IndexMaxPQ<Double> pq = new IndexMaxPQ<Double>(G.V());
     for (int v = 0; v < G.V(); v++) {
         if (v != cp.s && !marked[v]) pq.insert(v, 0.0);
     }
     pq.insert(cp.s, Double.POSITIVE_INFINITY);
     while (!pq.isEmpty()) {
         int v = pq.delMax();
         cp.s = cp.t;
         cp.t = v;
         for (Edge e : G.adj(v)) {
             int w = e.other(v);
             if (pq.contains(w)) pq.increaseKey(w, pq.keyOf(w) + e.weight());
         }
     }
     cp.weight = 0.0;
     for (Edge e : G.adj(cp.t)) {
         cp.weight += e.weight();
     }
     return cp;
 }
Exemplo n.º 12
0
        // 书中算法 2.6 给出的是最大堆,但本题自带的部分解答是最小堆形式的。
        // 这里和官网保持一致,实现最大堆。
        // 官网答案:https://algs4.cs.princeton.edu/24pq/IndexMaxPQ.java.html
        static void Main(string[] args)
        {
            string[] input = new string[] { "it", "was", "the", "best", "of", "times", "it", "was", "the", "worst" };

            IndexMaxPQ <string> pq = new IndexMaxPQ <string>(input.Length);

            for (int i = 0; i < input.Length; i++)
            {
                pq.Insert(input[i], i);
            }

            foreach (var i in pq)
            {
                Console.WriteLine(i + ". " + input[i]);
            }

            Console.WriteLine();

            Random random = new Random();

            for (int i = 0; i < input.Length; i++)
            {
                if (random.NextDouble() < 0.5)
                {
                    pq.IncreaseKey(i, input[i] + input[i]);
                }
                else
                {
                    pq.DecreaseKey(i, input[i].Substring(0, 1));
                }
            }

            while (!pq.IsEmpty())
            {
                string key = pq.MaxKey();
                int    i   = pq.DelMax();
                Console.WriteLine(i + "." + key);
            }

            Console.WriteLine();

            for (int i = 0; i < input.Length; i++)
            {
                pq.Insert(input[i], i);
            }

            int[] param = new int[input.Length];
            for (int i = 0; i < input.Length; i++)
            {
                param[i] = i;
            }

            Shuffle(param);

            for (int i = 0; i < param.Length; i++)
            {
                string key = pq.KeyOf(param[i]);
                pq.Delete(param[i]);
                Console.WriteLine(param[i] + "." + key);
            }
        }
Exemplo n.º 13
0
    // Use this for initialization
    void Start()
    {
        // insert a bunch of strings
        string[] strings = { "it", "was", "the", "best", "of", "times", "it", "was", "the", "worst" };

        IndexMaxPQ <string> pq = new IndexMaxPQ <string>(strings.Length);

        for (int i = 0; i < strings.Length; i++)
        {
            pq.insert(i, strings[i]);
        }

        // print each key using the iterator
        foreach (string i in pq)
        {
            print(i + " " + strings[int.Parse(i)]);
        }


        // increase or decrease the key
        for (int i = 0; i < strings.Length; i++)
        {
            if (Random.Range(0.0f, 1.0f) < 0.5)  // Random.uniform() 返回一个随机的范围在[0,1)之间的double类型的数
            {
                pq.increaseKey(i, strings[i] + strings[i]);
            }
            else
            {
                pq.decreaseKey(i, strings[i].Substring(0, 1));
            }
        }

        // delete and print each key
        while (!pq.isEmpty())
        {
            string key = pq.maxKey();
            int    i   = pq.delMax();
            print(i + " " + key);
        }

        // reinsert the same strings
        for (int i = 0; i < strings.Length; i++)
        {
            pq.insert(i, strings[i]);
        }

        // delete them in random order
        int[] perm = new int[strings.Length];
        for (int i = 0; i < strings.Length; i++)
        {
            perm[i] = i;
        }

        UnSort(perm);  // StdRandom.shuffle() 随机打乱指定的object型数组
        for (int i = 0; i < perm.Length; i++)
        {
            string key = pq.keyOf(perm[i]);
            pq.delete(perm[i]);
            print(perm[i] + " " + key);
        }
    }