結果
| 問題 | No.1995 CHIKA Road |
| ユーザー |
 terry_u16
|
| 提出日時 | 2022-07-01 21:51:10 |
| 言語 | C# (.NET 8.0.404) |
| 結果 |
AC
|
| 実行時間 | 435 ms / 2,000 ms |
| コード長 | 28,268 bytes |
| コンパイル時間 | 9,462 ms |
| コンパイル使用メモリ | 167,392 KB |
| 実行使用メモリ | 196,396 KB |
| 最終ジャッジ日時 | 2024-11-26 04:44:38 |
| 合計ジャッジ時間 | 16,507 ms |
|
ジャッジサーバーID （参考情報） |
judge4 / judge5 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 3 |
| other | AC * 37 |
コンパイルメッセージ
復元対象のプロジェクトを決定しています... /home/judge/data/code/main.csproj を復元しました (98 ms)。 MSBuild のバージョン 17.9.6+a4ecab324 (.NET) main -> /home/judge/data/code/bin/Release/net8.0/main.dll main -> /home/judge/data/code/bin/Release/net8.0/publish/
ソースコード
using System;
using System.Buffers;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics.X86;
using System.Text;
using YukicoderContest350.Problems;
namespace YukicoderContest350.Problems
{
public class ProblemD : ProblemBase
{
public ProblemD() : base(false) { }
[MethodImpl(MethodImplOptions.AggressiveOptimization)]
protected override void SolveEach(IOManager io)
{
var n = io.ReadLong();
var m = io.ReadInt();
var edges = new long[2 * (m + 1)];
for (int i = 0; i < m; i++)
{
edges[2 * i] = io.ReadInt();
edges[2 * i + 1] = io.ReadInt();
}
edges[^2] = 1;
edges[^1] = n;
var compressed = new CompressedCoordinate<long>(edges);
var graph = new WeightedGraph(compressed.UniqueCount);
for (int i = 0; i < m; i++)
{
var cost = 2 * edges[2 * i + 1] - 2 * edges[2 * i] - 1;
graph.AddEdge(compressed.Compressed[2 * i], compressed.Compressed[2 * i + 1], cost);
}
var values = edges.Distinct().OrderBy(i => i).ToArray();
for (int i = 0; i + 1 < values.Length; i++)
{
graph.AddEdge(i, i + 1, 2 * (values[i + 1] - values[i]));
}
var dijkstra = new Dijkstra(graph);
var distances = dijkstra.GetDistancesFrom(0);
var d = long.MaxValue;
for (int i = 0; i < m + 1; i++)
{
var v = compressed.Compressed[2 * i + 1];
d.ChangeMin(distances[v] + 2 * (n - edges[2 * i + 1]));
}
io.WriteLine(d);
}
public interface IEdge
{
int To { get; }
}
public interface IWeightedEdge : IEdge
{
long Weight { get; }
}
public interface IGraph<TEdge> where TEdge : IEdge
{
ReadOnlySpan<TEdge> this[int node] { get; }
int NodeCount { get; }
}
public interface IWeightedGraph<TEdge> : IGraph<TEdge> where TEdge : IWeightedEdge { }
public readonly struct BasicEdge : IEdge
{
public int To { get; }
public BasicEdge(int to)
{
To = to;
}
public override string ToString() => To.ToString();
public static implicit operator BasicEdge(int edge) => new BasicEdge(edge);
public static implicit operator int(BasicEdge edge) => edge.To;
}
[StructLayout(LayoutKind.Auto)]
public readonly struct WeightedEdge : IWeightedEdge
{
public int To { get; }
public long Weight { get; }
public WeightedEdge(int to) : this(to, 1) { }
public WeightedEdge(int to, long weight)
{
To = to;
Weight = weight;
}
public override string ToString() => $"[{Weight}]-->{To}";
public void Deconstruct(out int to, out long weight) => (to, weight) = (To, Weight);
}
public class BasicGraph : IGraph<BasicEdge>
{
private readonly List<List<BasicEdge>> _edges;
public ReadOnlySpan<BasicEdge> this[int node] => _edges[node].AsSpan();
public int NodeCount => _edges.Count;
public BasicGraph(int nodeCount)
{
_edges = new List<List<BasicEdge>>(nodeCount);
for (int i = 0; i < nodeCount; i++)
{
_edges.Add(new List<BasicEdge>());
}
}
public void AddEdge(int from, int to) => _edges[from].Add(to);
public void AddNode() => _edges.Add(new List<BasicEdge>());
}
public class WeightedGraph : IGraph<WeightedEdge>
{
private readonly List<List<WeightedEdge>> _edges;
public ReadOnlySpan<WeightedEdge> this[int node] => _edges[node].AsSpan();
public int NodeCount => _edges.Count;
public WeightedGraph(int nodeCount)
{
_edges = new List<List<WeightedEdge>>(nodeCount);
for (int i = 0; i < nodeCount; i++)
{
_edges.Add(new List<WeightedEdge>());
}
}
public void AddEdge(int from, int to, long weight) => _edges[from].Add(new WeightedEdge(to, weight));
public void AddNode() => _edges.Add(new List<WeightedEdge>());
}
public class Dijkstra
{
private readonly WeightedGraph _graph;
public Dijkstra(WeightedGraph graph)
{
_graph = graph;
}
public long[] GetDistancesFrom(int startNode)
{
const long Inf = 1L << 60;
var distances = Enumerable.Repeat(Inf, _graph.NodeCount).ToArray();
distances[startNode] = 0;
var todo = new PriorityQueue<State>(PriorityQueue<State>.Order.Ascending);
todo.Enqueue(new State(startNode, 0));
while (todo.Count > 0)
{
var current = todo.Dequeue();
if (current.Distance > distances[current.Node])
{
continue;
}
foreach (var edge in _graph[current.Node])
{
var nextDistance = current.Distance + edge.Weight;
if (distances[edge.To] > nextDistance)
{
distances[edge.To] = nextDistance;
todo.Enqueue(new State(edge.To, nextDistance));
}
}
}
return distances;
}
private readonly struct State : IComparable<State>
{
public int Node { get; }
public long Distance { get; }
public State(int node, long distance)
{
Node = node;
Distance = distance;
}
public int CompareTo(State other) => Distance.CompareTo(other.Distance);
public void Deconstruct(out int node, out long distance) => (node, distance) = (Node, Distance);
}
}
public class PriorityQueue<T> : IEnumerable<T> where T : IComparable<T>
{
const int InitialSize = 4;
private readonly int _reverseFactor;
private T[] _heap;
public int Count { get; private set; }
public bool IsDescending => _reverseFactor == 1;
public PriorityQueue(Order order)
{
_reverseFactor = order == Order.Ascending ? -1 : 1;
_heap = new T[InitialSize];
Count = 0;
}
public PriorityQueue(Order order, IEnumerable<T> collection) : this(order)
{
foreach (var item in collection)
{
Enqueue(item);
}
}
public void Enqueue(T item)
{
if (Count >= _heap.Length)
{
var temp = new T[_heap.Length << 1];
_heap.AsSpan().CopyTo(temp);
_heap = temp;
}
var index = Count++;
ref var child = ref _heap[index];
child = item;
while (index > 0)
{
index = (index - 1) >> 1;
ref var parent = ref _heap[index];
if (Compare(child, parent) <= 0)
{
break;
}
Swap(ref child, ref parent);
child = ref parent;
}
}
public T Dequeue()
{
var index = 0;
ref var parent = ref _heap[index];
var item = parent;
parent = _heap[--Count];
var span = _heap.AsSpan(0, Count);
while (true)
{
index = (index << 1) + 1;
if (unchecked((uint)index < (uint)span.Length))
{
ref var child = ref span[index];
var r = index + 1;
if (unchecked((uint)r < (uint)span.Length))
{
ref var brother = ref span[r];
if (Compare(child, brother) < 0)
{
child = ref brother;
index = r;
}
}
if (Compare(parent, child) < 0)
{
Swap(ref parent, ref child);
parent = ref child;
}
else
{
break;
}
}
else
{
break;
}
}
return item;
}
public T Peek() => _heap[0];
public void Clear() => Count = 0;
private int Compare(T a, T b) => _reverseFactor * a.CompareTo(b);
private void Swap(ref T a, ref T b)
{
var temp = a;
a = b;
b = temp;
}
public IEnumerator<T> GetEnumerator()
{
var copy = new T[_heap.Length];
var cnt = Count;
_heap.AsSpan().CopyTo(copy);
try
{
while (Count > 0)
{
yield return Dequeue();
}
}
finally
{
_heap = copy;
Count = cnt;
}
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
public enum Order
{
Ascending,
Descending
}
}
public class CompressedCoordinate<T> where T : IComparable<T>, IEquatable<T>
{
readonly int[] _compressed;
readonly T[] _raw;
readonly Dictionary<T, int> _converter;
readonly T[] _inverter;
public int UniqueCount => _inverter.Length;
/// <summary>
/// 座圧前のデータ列を返します。
/// </summary>
public ReadOnlySpan<T> Raw => _raw;
/// <summary>
/// 座圧後のデータ列を返します。
/// </summary>
public ReadOnlySpan<int> Compressed => _compressed;
/// <summary>
/// 座圧前のデータを座圧後のインデックスに変換します。
/// </summary>
public int Convert(T value) => _converter[value];
/// <summary>
/// 座圧後のインデックスを座圧前のデータに変換します。
/// </summary>
public T Invert(Index index) => _inverter[index];
public CompressedCoordinate(IEnumerable<T> data)
{
_raw = data.ToArray();
_converter = new Dictionary<T, int>();
_inverter = _raw.Distinct().ToArray();
Array.Sort(_inverter);
_compressed = new int[_raw.Length];
var span = _inverter.AsSpan();
for (int i = 0; i < _compressed.Length; i++)
{
_compressed[i] = span.BinarySearch(_raw[i]);
}
for (var i = 0; i < _inverter.Length; i++)
{
_converter[_inverter[i]] = i;
}
}
}
}
}
namespace YukicoderContest350
{
internal class Program
{
static void Main(string[] args)
{
IProblem question = new ProblemD();
using var io = new IOManager(Console.OpenStandardInput(), Console.OpenStandardOutput());
question.Solve(io);
}
}
}
#region Base Class
namespace YukicoderContest350.Problems
{
public interface IProblem
{
string Solve(string input);
void Solve(IOManager io);
}
public abstract class ProblemBase : IProblem
{
protected bool HasMultiTestCases { get; }
protected ProblemBase(bool hasMultiTestCases) => HasMultiTestCases = hasMultiTestCases;
public string Solve(string input)
{
var inputStream = new MemoryStream(Encoding.UTF8.GetBytes(input));
var outputStream = new MemoryStream();
using var manager = new IOManager(inputStream, outputStream);
Solve(manager);
manager.Flush();
outputStream.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(outputStream);
return reader.ReadToEnd();
}
public void Solve(IOManager io)
{
var tests = HasMultiTestCases ? io.ReadInt() : 1;
for (var t = 0; t < tests; t++)
{
SolveEach(io);
}
}
protected abstract void SolveEach(IOManager io);
}
}
#endregion
#region Utils
namespace YukicoderContest350
{
public class IOManager : IDisposable
{
private readonly BinaryReader _reader;
private readonly StreamWriter _writer;
private bool _disposedValue;
private byte[] _buffer = new byte[1024];
private int _length;
private int _cursor;
private bool _eof;
const char ValidFirstChar = '!';
const char ValidLastChar = '~';
public IOManager(Stream input, Stream output)
{
_reader = new BinaryReader(input);
_writer = new StreamWriter(output) { AutoFlush = false };
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private char ReadAscii()
{
if (_cursor == _length)
{
_cursor = 0;
_length = _reader.Read(_buffer);
if (_length == 0)
{
if (!_eof)
{
_eof = true;
return char.MinValue;
}
else
{
ThrowEndOfStreamException();
}
}
}
return (char)_buffer[_cursor++];
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public char ReadChar()
{
char c;
while (!IsValidChar(c = ReadAscii())) { }
return c;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadString()
{
var builder = new StringBuilder();
char c;
while (!IsValidChar(c = ReadAscii())) { }
do
{
builder.Append(c);
} while (IsValidChar(c = ReadAscii()));
return builder.ToString();
}
public int ReadInt() => (int)ReadLong();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public long ReadLong()
{
long result = 0;
bool isPositive = true;
char c;
while (!IsNumericChar(c = ReadAscii())) { }
if (c == '-')
{
isPositive = false;
c = ReadAscii();
}
do
{
result *= 10;
result += c - '0';
} while (IsNumericChar(c = ReadAscii()));
return isPositive ? result : -result;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private Span<char> ReadChunk(Span<char> span)
{
var i = 0;
char c;
while (!IsValidChar(c = ReadAscii())) { }
do
{
span[i++] = c;
} while (IsValidChar(c = ReadAscii()));
return span.Slice(0, i);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double ReadDouble() => double.Parse(ReadChunk(stackalloc char[32]));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public decimal ReadDecimal() => decimal.Parse(ReadChunk(stackalloc char[32]));
public int[] ReadIntArray(int n)
{
var a = new int[n];
for (int i = 0; i < a.Length; i++)
{
a[i] = ReadInt();
}
return a;
}
public long[] ReadLongArray(int n)
{
var a = new long[n];
for (int i = 0; i < a.Length; i++)
{
a[i] = ReadLong();
}
return a;
}
public double[] ReadDoubleArray(int n)
{
var a = new double[n];
for (int i = 0; i < a.Length; i++)
{
a[i] = ReadDouble();
}
return a;
}
public decimal[] ReadDecimalArray(int n)
{
var a = new decimal[n];
for (int i = 0; i < a.Length; i++)
{
a[i] = ReadDecimal();
}
return a;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write<T>(T value) => _writer.Write(value.ToString());
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WriteLine<T>(T value) => _writer.WriteLine(value.ToString());
public void WriteLine<T>(IEnumerable<T> values, char separator)
{
var e = values.GetEnumerator();
if (e.MoveNext())
{
_writer.Write(e.Current.ToString());
while (e.MoveNext())
{
_writer.Write(separator);
_writer.Write(e.Current.ToString());
}
}
_writer.WriteLine();
}
public void WriteLine<T>(T[] values, char separator) => WriteLine((ReadOnlySpan<T>)values, separator);
public void WriteLine<T>(Span<T> values, char separator) => WriteLine((ReadOnlySpan<T>)values, separator);
public void WriteLine<T>(ReadOnlySpan<T> values, char separator)
{
for (int i = 0; i < values.Length - 1; i++)
{
_writer.Write(values[i]);
_writer.Write(separator);
}
if (values.Length > 0)
{
_writer.Write(values[^1]);
}
_writer.WriteLine();
}
public void Flush() => _writer.Flush();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static bool IsValidChar(char c) => ValidFirstChar <= c && c <= ValidLastChar;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static bool IsNumericChar(char c) => ('0' <= c && c <= '9') || c == '-';
private void ThrowEndOfStreamException() => throw new EndOfStreamException();
protected virtual void Dispose(bool disposing)
{
if (!_disposedValue)
{
if (disposing)
{
_reader.Dispose();
_writer.Flush();
_writer.Dispose();
}
_disposedValue = true;
}
}
public void Dispose()
{
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}
public static class UtilExtensions
{
public static bool ChangeMax<T>(ref this T value, T other) where T : struct, IComparable<T>
{
if (value.CompareTo(other) < 0)
{
value = other;
return true;
}
return false;
}
public static bool ChangeMin<T>(ref this T value, T other) where T : struct, IComparable<T>
{
if (value.CompareTo(other) > 0)
{
value = other;
return true;
}
return false;
}
public static void SwapIfLargerThan<T>(ref this T a, ref T b) where T : struct, IComparable<T>
{
if (a.CompareTo(b) > 0)
{
(a, b) = (b, a);
}
}
public static void SwapIfSmallerThan<T>(ref this T a, ref T b) where T : struct, IComparable<T>
{
if (a.CompareTo(b) < 0)
{
(a, b) = (b, a);
}
}
public static void Sort<T>(this T[] array) where T : IComparable<T> => Array.Sort(array);
public static void Sort<T>(this T[] array, Comparison<T> comparison) => Array.Sort(array, comparison);
}
public static class CollectionExtensions
{
private class ArrayWrapper<T>
{
#pragma warning disable CS0649
public T[] Array;
#pragma warning restore CS0649
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Span<T> AsSpan<T>(this List<T> list)
{
return Unsafe.As<ArrayWrapper<T>>(list).Array.AsSpan(0, list.Count);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Span<T> GetRowSpan<T>(this T[,] array, int i)
{
var width = array.GetLength(1);
return MemoryMarshal.CreateSpan(ref array[i, 0], width);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Span<T> GetRowSpan<T>(this T[,,] array, int i, int j)
{
var width = array.GetLength(2);
return MemoryMarshal.CreateSpan(ref array[i, j, 0], width);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Span<T> GetRowSpan<T>(this T[,,,] array, int i, int j, int k)
{
var width = array.GetLength(3);
return MemoryMarshal.CreateSpan(ref array[i, j, k, 0], width);
}
public static void Fill<T>(this T[] array, T value) => array.AsSpan().Fill(value);
public static void Fill<T>(this T[,] array, T value) => MemoryMarshal.CreateSpan(ref array[0, 0], array.Length).Fill(value);
public static void Fill<T>(this T[,,] array, T value) => MemoryMarshal.CreateSpan(ref array[0, 0, 0], array.Length).Fill(value);
public static void Fill<T>(this T[,,,] array, T value) => MemoryMarshal.CreateSpan(ref array[0, 0, 0, 0], array.Length).Fill(value);
}
public static class SearchExtensions
{
private struct LowerBoundComparer<T> : IComparer<T> where T : IComparable<T>
{
public int Compare(T x, T y) => 0 <= x.CompareTo(y) ? 1 : -1;
}
private struct UpperBoundComparer<T> : IComparer<T> where T : IComparable<T>
{
public int Compare(T x, T y) => 0 < x.CompareTo(y) ? 1 : -1;
}
// https://trsing.hatenablog.com/entry/2019/08/27/211038
public static int GetGreaterEqualIndex<T>(this ReadOnlySpan<T> span, T inclusiveMin) where T : IComparable<T> => ~span.BinarySearch(inclusiveMin, new UpperBoundComparer<T>());
public static int GetGreaterThanIndex<T>(this ReadOnlySpan<T> span, T exclusiveMin) where T : IComparable<T> => ~span.BinarySearch(exclusiveMin, new LowerBoundComparer<T>());
public static int GetLessEqualIndex<T>(this ReadOnlySpan<T> span, T inclusiveMax) where T : IComparable<T> => ~span.BinarySearch(inclusiveMax, new LowerBoundComparer<T>()) - 1;
public static int GetLessThanIndex<T>(this ReadOnlySpan<T> span, T exclusiveMax) where T : IComparable<T> => ~span.BinarySearch(exclusiveMax, new UpperBoundComparer<T>()) - 1;
public static int GetGreaterEqualIndex<T>(this Span<T> span, T inclusiveMin) where T : IComparable<T> => ((ReadOnlySpan<T>)span).GetGreaterEqualIndex(inclusiveMin);
public static int GetGreaterThanIndex<T>(this Span<T> span, T exclusiveMin) where T : IComparable<T> => ((ReadOnlySpan<T>)span).GetGreaterThanIndex(exclusiveMin);
public static int GetLessEqualIndex<T>(this Span<T> span, T inclusiveMax) where T : IComparable<T> => ((ReadOnlySpan<T>)span).GetLessEqualIndex(inclusiveMax);
public static int GetLessThanIndex<T>(this Span<T> span, T exclusiveMax) where T : IComparable<T> => ((ReadOnlySpan<T>)span).GetLessThanIndex(exclusiveMax);
public static int BoundaryBinarySearch(Predicate<int> predicate, int ok, int ng)
{
while (Math.Abs(ok - ng) > 1)
{
var mid = (ok + ng) / 2;
if (predicate(mid))
{
ok = mid;
}
else
{
ng = mid;
}
}
return ok;
}
public static long BoundaryBinarySearch(Predicate<long> predicate, long ok, long ng)
{
while (Math.Abs(ok - ng) > 1)
{
var mid = (ok + ng) / 2;
if (predicate(mid))
{
ok = mid;
}
else
{
ng = mid;
}
}
return ok;
}
public static BigInteger BoundaryBinarySearch(Predicate<BigInteger> predicate, BigInteger ok, BigInteger ng)
{
while (BigInteger.Abs(ok - ng) > 1)
{
var mid = (ok + ng) / 2;
if (predicate(mid))
{
ok = mid;
}
else
{
ng = mid;
}
}
return ok;
}
public static double BoundaryBinarySearch(Predicate<double> predicate, double ok, double ng, double eps = 1e-9, int loopLimit = 1000)
{
var count = 0;
while (Math.Abs(ok - ng) > eps && count++ < loopLimit)
{
var mid = (ok + ng) * 0.5;
if (predicate(mid))
{
ok = mid;
}
else
{
ng = mid;
}
}
return (ok + ng) * 0.5;
}
public static double Bisection(Func<double, double> f, double a, double b, double eps = 1e-9, int loopLimit = 100)
{
double mid = (a + b) / 2;
var fa = f(a);
if (fa * f(b) >= 0)
{
throw new ArgumentException("f(a)とf(b)は異符号である必要があります。");
}
for (int i = 0; i < loopLimit; i++)
{
var fmid = f(mid);
var sign = fa * fmid;
if (sign < 0)
{
b = mid;
}
else if (sign > 0)
{
a = mid;
fa = fmid;
}
else
{
return mid;
}
mid = (a + b) / 2;
if (Math.Abs(b - a) < eps)
{
break;
}
}
return mid;
}
}
}
#endregion