Exemplo n.º 1
0
        public bool Contains(Point pt)
        {
            // roate the rectangle angle degree counter-clockwise
            Point[] ptsRotated = new Point[4];
            Point   transpt;
            int     x, y;
            double  sin   = Math.Sin(angle / 180 * Math.PI);
            double  cosin = Math.Cos(angle / 180 * Math.PI);

            for (int i = 0; i < 4; i++)
            {
                transpt       = PA.Subtract(corners[i], center);
                x             = Convert.ToInt32(transpt.X * cosin + transpt.Y * sin + center.X);
                y             = Convert.ToInt32(transpt.X * -sin + transpt.Y * cosin + center.Y);
                ptsRotated[i] = new Point(x, y);
            }
            List <int> xs = ptsRotated.OrderBy(p => p.X).Select(p => p.X).ToList();
            List <int> ys = ptsRotated.OrderBy(p => p.Y).Select(p => p.Y).ToList();
            //Size size = new Size(Math.Abs(ptsRotated[0].X - ptsRotated[2].X),
            //                     Math.Abs(ptsRotated[0].Y - ptsRotated[2].Y));
            Rectangle rect = new Rectangle(xs[0], ys[0], xs[3] - xs[0], ys[3] - ys[0]);

            // apply rotation to point p
            transpt = new Point(pt.X - center.X, pt.Y - center.Y);
            x       = Convert.ToInt32(transpt.X * cosin + transpt.Y * sin + center.X);
            y       = Convert.ToInt32(transpt.X * -sin + transpt.Y * cosin + center.Y);
            bool isContained = rect.Contains(new Point(x, y));

            return(isContained);
        }
Exemplo n.º 2
0
    public static void Exécute(TextReader input, TextWriter output)
    {
        int N = int.Parse(input.ReadLine());

        Point[] points = new Point[N];
        for (int i = 0; i < N; i++)
        {
            string[] inputs = input.ReadLine().Split(' ');
            int      X      = int.Parse(inputs[0]);
            int      Y      = int.Parse(inputs[1]);
            points[i].y = Y;
            points[i].x = X;
        }

        if (N == 1)
        {
            output.WriteLine("0");
            return;
        }

        var y  = points.Select(x => x.y).ToArray();
        var xs = points.Select(x => x.x).ToArray();

        var sorted = points.OrderBy(x => x.y).ToArray();
        var middle = sorted.Length / 2;

        int minY = sorted[middle - 1].y;
        int maxY = sorted[middle].y;

        points = points.OrderBy(x => x.x).ToArray();

        long upValue   = Len(y, minY);
        long downValue = Len(y, maxY);

        while (minY < maxY - 1)
        {
            int  mid      = (minY + maxY) / 2;
            long midValue = Len(y, mid);
            if (upValue < downValue)
            {
                maxY      = mid;
                downValue = midValue;
            }
            else
            {
                minY    = mid;
                upValue = midValue;
            }
        }

        // Write an action using Console.WriteLine()
        // To debug: Console.Error.WriteLine("Debug messages...");

        output.WriteLine(Math.Min(upValue, downValue) + xs.Max() - xs.Min());
    }
Exemplo n.º 3
0
        public override void Reorder()
        {
            Point [] array = new Point [] { Start, Stop, StartI, StopI };

            array = array.OrderBy(p => p.X).ThenBy(p => p.Y).ToArray();
            Start = array [0];
            Stop  = array [3];
        }
Exemplo n.º 4
0
        public override void Reorder()
        {
            Point [] array = new Point[] { TopLeft, TopRight, BottomLeft, BottomRight };

            array       = array.OrderBy(p => p.X).ThenBy(p => p.Y).ToArray();
            TopLeft     = array[0];
            BottomLeft  = array[1];
            TopRight    = array[2];
            BottomRight = array[3];
        }
Exemplo n.º 5
0
        public static void Main()
        {
            var n      = int.Parse(ReadLine().Trim());
            var points = new Point[n];

            for (int x, y, i = 0; i < points.Length; ++i)
            {
                Read(ReadLine().Trim(), out x, out y);
                points[i] = new Point(i, x, y);
            }
            var dist = new Distance[n * 2 - 2];

            points = points.OrderBy(_ => _.X).ToArray();
            for (var i = 1; i < points.Length; ++i)
            {
                dist[i - 1] = new Distance(points[i - 1].Id, points[i].Id, points[i].X - points[i - 1].X);
            }
            points = points.OrderBy(_ => _.Y).ToArray();
            for (var i = 1; i < points.Length; ++i)
            {
                dist[i + points.Length - 2] = new Distance(points[i - 1].Id, points[i].Id, points[i].Y - points[i - 1].Y);
            }
            dist = dist.OrderBy(_ => _.Dist).ToArray();
            var uft = new UnionFindTree[n];

            for (var i = 0; i < uft.Length; ++i)
            {
                uft[i] = new UnionFindTree();
            }
            long res = 0;

            foreach (var d in dist)
            {
                if (!uft[d.From].IsSameUnion(uft[d.To]))
                {
                    res += d.Dist;
                    uft[d.From].MergeUnion(uft[d.To]);
                }
            }
            WriteLine(res);
        }
Exemplo n.º 6
0
    static void Main()
    {
        Point[] points = new Point[]
        {
            new Point(2, 2),
            new Point(3, 1),
            new Point(3, 2),
            new Point(1, 3)
        };

        var sortedPoints = points
                           .OrderBy(p => p.X)
                           .ThenBy(p => p.Y);
    }
Exemplo n.º 7
0
        public override void Reorder()
        {
            Point[] array = new Point[] { Start, Stop, StartI, StopI };

            array = array.OrderBy (p => p.X).ThenBy (p => p.Y).ToArray ();
            Start = array [0];
            Stop = array [3];
        }
Exemplo n.º 8
0
 public void Question9_Two_Dimension_Sort()
 {
     Point[] input = new Point[] {new Point(56, 90), new Point(60, 95),  new Point(65, -10), new Point(68, 99),
         new Point(69, 110), new Point(70, 100), new Point(75, 0), new Point(76, 180)};
     // step 1, sort by X
     input = input.OrderBy(p => p.X).ToArray();
     // step 2, get the longest increasing subsequence (LIS) in the array, compare Y
     int[] L = new int[input.Length]; // L[i] stores the LIS.length, from input[0] to input[i], LIS ends with input[i]
     // L[0] = 1, L[i] = max(L[k] + 1, 1)  when 0 <= k < i, input[k] < input[i]
     L[0] = 1;
     for (int i = 1; i < input.Length; i++)
     {
         L[i] = 1; // if before data[i], all the element is larger than data[i], the LIS ends with data[i]'s length is only 1
         for (int j = 0; j < i; j++)
         {
             if (input[i].Y > input[j].Y)
             {
                 L[i] = Math.Max(L[i], L[j] + 1);
             }
         }
     }
     // output: now we get a L[input.lenght] result, reverse enumerate
     int max = L.Max();
     for (int i = input.Length - 1; i >= 0; i--)
     {
         if (L[i] == max)
         {
             Console.WriteLine(input[i]);
             max--;
         }
     }
 }
Exemplo n.º 9
0
        private void Ендрю_Джавірса_Click(object sender, EventArgs e)
        {
            if (n < 2)
            {
                label1.Text = "Введіть більше точок";
                return;
            }
            label1.Text = "";

            Point[] x_arr = new Point[n];
            IEnumerable<Point> x_sort_enum;
            Point[] x_sort;
            for (int i = 0; i < n; ++i)
                x_arr[i] = new Point(points_arr[i].X, points_arr[i].Y);
            x_sort_enum = x_arr.OrderBy(p => p.X);
            x_sort = x_sort_enum.ToArray();
            Point left = new Point(x_sort[0].X, x_sort[0].Y);
            Point right = new Point(x_sort[n-1].X, x_sort[n-1].Y);
            int n_up = 0, n_down = 0;
            Point[] up = new Point[n];
            Point[] down = new Point[n];
            int iup = 0, idown = 0;

            up[iup++] = new Point(left.X, left.Y);
            down[idown++] = new Point(left.X, left.Y);
            // верхний и нижний массивы
            foreach (Point p in x_sort)
            {
            if(point_is_left_AB(left, right, p))
                up[iup++] = new Point(p.X, p.Y);
            else if(point_is_right_AB(left, right, p))
                down[idown++] = new Point(p.X, p.Y);
            }
            up[iup++] = new Point(right.X, right.Y);
            down[idown++] = new Point(right.X, right.Y);
            bool[] in_ob_up = new bool[iup];
            bool[] in_ob_down = new bool[idown];
            in_ob_up.Initialize();
            in_ob_down.Initialize();
            in_ob_up[0] = true;
            in_ob_up[iup - 1] = true;
            in_ob_down[0] = true;
            in_ob_down[idown - 1] = true;
            // обработка верхнего
            for (int i = 0; i < iup - 1;)
            {
                int index_of_max_angle = index_max_angle_up(iup, up, i);
                in_ob_up[index_of_max_angle] = true;
                i = index_of_max_angle;
            }
             //обработка нижнего массива
            for (int i = 0; i < idown - 1;)
            {
                int index_of_max_angle = index_max_angle_down(idown, down, i);
                in_ob_down[index_of_max_angle] = true;
                i = index_of_max_angle;
            }

            // рисуем
            Draw();
            Gl.glPolygonMode(Gl.GL_FRONT_AND_BACK, Gl.GL_LINE);
            Gl.glBegin(Gl.GL_POLYGON);
            Gl.glColor3d(1, 0, 0);
            for (int i = 0; i < iup; ++i)
            {
                if(in_ob_up[i])
                    Gl.glVertex2d(up[i].X, up[i].Y);
            }

            Gl.glColor3d(0, 0, 1);
            for (int i = idown - 1; i >= 0; --i)
            {
                if (in_ob_down[i])
                    Gl.glVertex2d(down[i].X, down[i].Y);
            }
            Gl.glEnd();
            AnT.Invalidate();
            Gl.glFlush();
                return;
        }
Exemplo n.º 10
0
 void phi()
 {
     Point[] points_in_new_coord_where_Q_center = new Point[n];
     int qx = Q.Value.X, qy = Q.Value.Y;
     for (int i = 0; i < n; ++i)
         points_in_new_coord_where_Q_center[i] = new Point(points_arr[i].X - qx, points_arr[i].Y - qy);
     double [] phi_arr = new double[n];
     for (int i = 0; i < n; ++i)
     {
         int x = points_in_new_coord_where_Q_center[i].X, y = points_in_new_coord_where_Q_center[i].Y;
         double r = Math.Sqrt(x*x + y*y);
         phi_arr[i] = Math.Asin(y)/r;
     }
     IEnumerable<Point> sort_enum_phi_arr;//
     Point [] sort_phi_arr = new Point[n];
     sort_enum_phi_arr = points_in_new_coord_where_Q_center.OrderBy(p => acos((p.X)/Math.Sqrt(p.X * p.X + p.Y * p.Y), p));
     sort_phi_arr = sort_enum_phi_arr.ToArray();
 }
Exemplo n.º 11
0
        // алгоритм Грехема
        private void button2_Click(object sender, EventArgs e)
        {
            if (n < 2)
            {
                label1.Text = "Введіть більше точок";
                return;
            }
            label1.Text = "";

            if (!Q.HasValue)
            {
                label1.Text = "Задайте внутрішню точку (правою кнопкою миші)";
                return;
            }
            //polar_sort
            // сортировка по полярному углу относительно точки Q
            Point[] points_in_new_coord_where_Q_center = new Point[n];
            int qx = Q.Value.X, qy = Q.Value.Y;
            for (int i = 0; i < n; ++i)
                points_in_new_coord_where_Q_center[i] = new Point(points_arr[i].X - qx, points_arr[i].Y - qy);
            double[] phi_arr = new double[n];
            for (int i = 0; i < n; ++i)
            {
                int x = points_in_new_coord_where_Q_center[i].X, y = points_in_new_coord_where_Q_center[i].Y;
                double r = Math.Sqrt(x*x + y*y);
                phi_arr[i] = Math.Asin(y)/r;
            }
            IEnumerable<Point> sort_enum_phi_arr;//
            Point[] sort_phi_arr = new Point[n];
            sort_enum_phi_arr = points_in_new_coord_where_Q_center.OrderBy(p => acos((p.X)/Math.Sqrt(p.X * p.X + p.Y * p.Y), p));
            sort_phi_arr = sort_enum_phi_arr.ToArray();

            // end_polar_sort
            Point[] sort_points_arr = new Point[n];
            for (int i = 0; i < n; ++i)
                sort_points_arr[i] = new Point(sort_phi_arr[i].X + qx, sort_phi_arr[i].Y + qy);

            bool[] is_ob = new bool[n];
            is_ob.Initialize();
            is_ob[0] = true;
            is_ob[1] = true;
            bool for_exit = false;
            for (int i = 2; i < n; ++i)
            {
                is_ob[i] = true;
                for (int j = i - 1; j > 0; --j)
                    if (is_ob[j])
                    {
                        for (int k = j - 1; k >= 0; --k)
                            if (is_ob[k])
                            {
                                for_exit = false;
                                if (point_is_left_AB(sort_points_arr[k], sort_points_arr[i], sort_points_arr[j]))
                                {
                                    is_ob[j] = false;
                                    for_exit = false;
                                }
                                else
                                    for_exit = true;
                                break;
                            }
                        if (for_exit)
                            break;
                    }
            }
             //для последней точки (замыкающей)
            int last_in_ob = 0;
            for (int i = n - 2; i > 0; --i)
            {
                if (is_ob[i])
                {
                    if (point_is_left_AB(sort_points_arr[i], sort_points_arr[0], sort_points_arr[n-1]))
                        is_ob[n-1] = false;
                    last_in_ob = i;
                    break;
                }
            }

            for (int i = 1; i < n; ++i)
            {
                {
                    if (is_ob[i])
                        if (point_is_left_AB(sort_points_arr[last_in_ob], sort_points_arr[i], sort_points_arr[0]))
                            is_ob[0] = false;
                    break;
                }
            }

                Draw();
            Gl.glColor3d(0, 0, 1);
            Gl.glPolygonMode(Gl.GL_FRONT_AND_BACK, Gl.GL_LINE);
            Gl.glBegin(Gl.GL_POLYGON);
            for (int i = 0; i < n; ++i)
                if (is_ob[i])
                Gl.glVertex2d(sort_points_arr[i].X, sort_points_arr[i].Y);
            Gl.glEnd();
            for (int i = 0; i < n; ++i)
            {

                Gl.glRasterPos2d(sort_phi_arr[i].X + qx, sort_phi_arr[i].Y + qy);
                string text = (i+1).ToString();
                // в цикле foreach перебираем значения из массива text,
                // который содержит значение строки для визуализации
                foreach (char char_for_draw in text)
                {
                    // визуализируем символ c, с помощью функции glutBitmapCharacter, используя шрифт GLUT_BITMAP_9_BY_15.
                    Glut.glutBitmapCharacter(Glut.GLUT_BITMAP_9_BY_15, char_for_draw);
                }
            }

            Gl.glFlush();
            AnT.Invalidate();
        }