Submission #11486600


Source Code Expand

using System;
using System.Linq;
using System.Collections.Generic;

namespace Contest
{
    class Program
    {
        static void Main(string[] args)
        {
            ARC076.D();
        }

        class ARC076
        {
            public static void C()
            {
                var N = Read.Int();
                var M = Read.Int();
                if (Math.Abs(N - M) > 1) { Console.WriteLine(0);return; }
                long ans = 1;
                long P = 1000000007;
                for (int i = 1; i <= N; ++i)
                {
                    ans = (ans * i) % P;
                }
                for (int i = 1; i <= M; ++i)
                {
                    ans = (ans * i) % P;
                }
                if (N == M) { ans = (ans * 2) % P; }
                Console.WriteLine(ans);
            }
            public static void D()
            {
                var N = Read.Int();
                var XY = Read.TupleLong(N);
                Tuple<long, int>[] X = Enumerable.Range(0, N).Select(i => new Tuple<long, int>(XY[i].Item1, i)).ToArray();
                Tuple<long, int>[] Y = Enumerable.Range(0, N).Select(i => new Tuple<long, int>(XY[i].Item2, i)).ToArray();
                Array.Sort(X, (a, b) => a.Item1.CompareTo(b.Item1));
                Array.Sort(Y, (a, b) => a.Item1.CompareTo(b.Item1));
                List<Tuple<long, int, int>> edge = new List<Tuple<long, int, int>>();
                for(int i = 0; i < N - 1; ++i)
                {
                    edge.Add(new Tuple<long, int, int>(X[i + 1].Item1 - X[i].Item1, X[i].Item2, X[i + 1].Item2));
                    edge.Add(new Tuple<long, int, int>(Y[i + 1].Item1 - Y[i].Item1, Y[i].Item2, Y[i + 1].Item2));
                }
                var sortedEdge = edge.ToArray();
                Array.Sort(sortedEdge, (a, b) => a.Item1.CompareTo(b.Item1));
                var uft = new Util.UnionFindTree(N);
                long sum = 0;
                foreach(var e in sortedEdge)
                {
                    if (uft.Root(e.Item2) != uft.Root(e.Item3))
                    {
                        uft.Unite(e.Item2, e.Item3);
                        sum += e.Item1;
                    }
                }
                Console.WriteLine(sum);
            }
        }



        class Util
        {
            public class UnionFindTree
            { //各Treeのサイズを保持する拡張仕様
                int[] parent;
                int[] count;
                public UnionFindTree(int n) { parent = new int[n]; count = new int[n]; for (int i = 0; i < n; ++i) { parent[i] = i; count[i] = 1; } }
                public int Root(int i) { if (parent[i] == i) { return i; } else { return parent[i] = Root(parent[i]); } }
                public int Count(int i) { return count[Root(i)]; }
                public bool Same(int i, int j) { return Root(i) == Root(j); }
                public void Unite(int i, int j) { var ri = Root(i); var rj = Root(j); if (ri != rj) { parent[ri] = rj; count[rj] += count[ri]; } }
            }

        }


        static class Read
        {
            static Queue<string> queue = new Queue<string>();
            static void Enqueue() { var ss = Console.ReadLine().Split(' '); foreach (var s in ss) { queue.Enqueue(s); } }
            public static int Int() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt32(queue.Dequeue()); }
            public static long Long() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt64(queue.Dequeue()); }
            public static string Str() { if (queue.Count == 0) { Enqueue(); } return queue.Dequeue(); }
            public static int[] IntN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt32(s)).ToArray(); }
            public static long[] LongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt64(s)).ToArray(); }
            public static string[] StrN() { return Console.ReadLine().Split(' '); }
            public static Tuple<int, int>[] TupleInt(int n) { List<Tuple<int, int>> list = new List<Tuple<int, int>>(); for (int i = 0; i < n; ++i) { var ab = Read.IntN(); list.Add(new Tuple<int, int>(ab[0], ab[1])); } return list.ToArray(); }
            public static Tuple<long, long>[] TupleLong(int n) { List<Tuple<long, long>> list = new List<Tuple<long, long>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<long, long>(ab[0], ab[1])); } return list.ToArray(); }
            public static Tuple<string, string>[] TupleStr(int n) { List<Tuple<string, string>> list = new List<Tuple<string, string>>(); for (int i = 0; i < n; ++i) { var ab = Read.StrN(); list.Add(new Tuple<string, string>(ab[0], ab[1])); } return list.ToArray(); }
            public static Tuple<double, double>[] TupleDouble(int n) { List<Tuple<double, double>> list = new List<Tuple<double, double>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<double, double>(ab[0], ab[1])); } return list.ToArray(); }
            public static long[,] LongMatrix(int r, int c)
            {
                var mat = new long[r, c];
                for (int i = 0; i < r; ++i)
                {
                    var x = Read.LongN();
                    for (int j = 0; j < c; ++j)
                    {
                        mat[i, j] = x[j];
                    }
                }
                return mat;
            }
            public static Dictionary<int, HashSet<int>> AdjacencyList(int N, int M)
            {
                Dictionary<int, HashSet<int>> dict = new Dictionary<int, HashSet<int>>();
                for (int i = 0; i <= N; ++i)
                {
                    dict.Add(i, new HashSet<int>());
                }
                for (int i = 0; i < M; ++i)
                {
                    var ab = Read.IntN();
                    dict[ab[0]].Add(ab[1]);
                    dict[ab[1]].Add(ab[0]);
                }
                return dict;
            }
            public static Dictionary<int, Dictionary<int, long>> AdjacencyListWithWeight(int N, int M)
            {
                Dictionary<int, Dictionary<int, long>> dict = new Dictionary<int, Dictionary<int, long>>();
                for (int i = 0; i <= N; ++i)
                {
                    dict.Add(i, new Dictionary<int, long>());
                }
                for (int i = 0; i < M; ++i)
                {
                    var ab = Read.IntN();
                    dict[ab[0]].Add(ab[1], ab[2]);
                    dict[ab[1]].Add(ab[0], ab[2]);
                }
                return dict;
            }
        }
    }
}

Submission Info

Submission Time
Task D - Built?
User UsagiSony
Language C# (Mono 4.6.2.0)
Score 500
Code Size 6805 Byte
Status AC
Exec Time 491 ms
Memory 42956 KB

Judge Result

Set Name Sample All
Score / Max Score 0 / 0 500 / 500
Status
AC × 2
AC × 28
Set Name Test Cases
Sample s1.txt, s2.txt
All 01.txt, 02.txt, 03.txt, 04.txt, 05.txt, 06.txt, 07.txt, 08.txt, 09.txt, 10.txt, 11.txt, 12.txt, 13.txt, 14.txt, 15.txt, 16.txt, 17.txt, 18.txt, 19.txt, 20.txt, 21.txt, 22.txt, 23.txt, 24.txt, 25.txt, 26.txt, s1.txt, s2.txt
Case Name Status Exec Time Memory
01.txt AC 489 ms 38328 KB
02.txt AC 476 ms 38324 KB
03.txt AC 488 ms 36280 KB
04.txt AC 474 ms 40372 KB
05.txt AC 485 ms 36268 KB
06.txt AC 479 ms 38324 KB
07.txt AC 480 ms 40376 KB
08.txt AC 482 ms 38320 KB
09.txt AC 479 ms 42932 KB
10.txt AC 472 ms 38964 KB
11.txt AC 470 ms 40884 KB
12.txt AC 470 ms 42936 KB
13.txt AC 452 ms 42608 KB
14.txt AC 453 ms 38512 KB
15.txt AC 445 ms 38512 KB
16.txt AC 481 ms 36456 KB
17.txt AC 470 ms 36792 KB
18.txt AC 462 ms 38072 KB
19.txt AC 452 ms 38512 KB
20.txt AC 460 ms 42608 KB
21.txt AC 491 ms 38512 KB
22.txt AC 453 ms 38076 KB
23.txt AC 435 ms 42956 KB
24.txt AC 444 ms 38848 KB
25.txt AC 31 ms 11476 KB
26.txt AC 31 ms 9428 KB
s1.txt AC 31 ms 11476 KB
s2.txt AC 32 ms 11476 KB