public void Solve()
{
int N = Reader.Int();
var G = EdgeRead(N);
int K = Reader.Int();
var Val = Enu.Repeat(Unknown, N).ToArray();
var heap = new Heap <long>();
for (int i = 0; i < K; i++)
{
int at = Reader.Int() - 1, val = Reader.Int();
Val[at] = val;
heap.Push(((long)val << 32) + at);
}
while (heap.Count > 0)
{
long mask = heap.Pop();
int val = (int)(mask >> 32);
int at = (int)mask;
foreach (int next in G[at])
{
if (Val[next] == Unknown)
{
heap.Push(((long)val + 1 << 32) + next);
Val[next] = val + 1;
}
else if (Math.Abs(Val[next] - val) != 1)
{
Console.WriteLine("No"); return;
}
}
}
Console.WriteLine("Yes\n" + string.Join("\n", Val));
}
static int[][] GridBFS(string[] grid, int sr, int sc, char badCell = '#')
{
int H = grid.Length, W = grid[0].Length;
var dist = new int[H][];
for (int r = 0; r < H; r++)
{
dist[r] = Enu.Repeat(INF, W).ToArray();
}
dist[sr][sc] = 0;
var que = new Queue <int>();
que.Enqueue(sr); que.Enqueue(sc);
Func <int, int, bool> IsInside = (r, c) => r >= 0 && r < H && c >= 0 && c < W;
while (que.Count > 0)
{
int r = que.Dequeue(), c = que.Dequeue();
for (int d = 0; d < DR.Length; d++)
{
int nr = r + DR[d], nc = c + DC[d];
if (IsInside(nr, nc) && grid[nr][nc] != badCell && dist[nr][nc] == INF)
{
dist[nr][nc] = dist[r][c] + 1;
que.Enqueue(nr); que.Enqueue(nc);
}
}
}
return(dist);
}
private Tuple <Term, Term[]> TwoSilhouettesSingleFeature(TSnapped snappedPrimitive, ISet <FeatureCurve> annotated)
{
var sil0 = SegmentApproximator.ApproximateSegment(snappedPrimitive.LeftSilhouette.Points);
var sil1 = SegmentApproximator.ApproximateSegment(snappedPrimitive.RightSilhouette.Points);
var axis2d = Get2DVector(snappedPrimitive.AxisResult);
var isTopSnapped = snappedPrimitive.TopFeatureCurve.SnappedTo != null;
var isBottomSnapped = snappedPrimitive.BottomFeatureCurve.SnappedTo != null;
var snappedFeatureCurve = isTopSnapped ? snappedPrimitive.TopFeatureCurve : snappedPrimitive.BottomFeatureCurve;
var unsnappedFeatureCurve = isTopSnapped ? snappedPrimitive.BottomFeatureCurve : snappedPrimitive.TopFeatureCurve;
var sil0Top = GetForwardPoint(sil0, axis2d);
var sil0Bot = GetForwardPoint(sil0, -axis2d);
var sil1Top = GetForwardPoint(sil1, axis2d);
var sil1Bot = GetForwardPoint(sil1, -axis2d);
var sil0Far = isTopSnapped ? sil0Bot : sil0Top;
var sil1Far = isTopSnapped ? sil1Bot : sil1Top;
var featureProj = ProjectionFit.Compute(snappedFeatureCurve);
var farProj = Enumerable.Repeat(EndpointsProjectionFit(unsnappedFeatureCurve, sil0Far, sil1Far), 1);
var objective = TermUtils.SafeSum(new Term[] { TermUtils.SafeAvg(featureProj), TermUtils.SafeAvg(farProj) });
var constraints = new Term[] { snappedPrimitive.Axis.NormSquared - 1 };
return(Tuple.Create(objective, constraints));
}
void Dijkstra()
{
var q = new MinHeap();
q.Push(0);
while (q.Count > 0)
{
var key = q.Pop();
int a, used, cost;
Decompress(key, out a, out used, out cost);
if (cost > MinCost[a][used - MinUsed[a]])
{
continue;
}
foreach (int b in E1[a])
{
Update(b, used, cost + 1, q);
}
foreach (int b in E2[a])
{
Update(b, used + 1, cost + used + 1, q);
}
}
Ans = Enu.Repeat(INF, N).ToArray();
for (int i = 0; i < N; i++)
{
foreach (int v in MinCost[i])
{
CheckMin(ref Ans[i], v);
}
}
}
/// <summary>
/// Returns a sequence consisting of the head elements and the given tail element.
/// </summary>
public static IEnumerable <T> Concat <T>(this IEnumerable <T> head, T tail)
{
if (head == null)
{
throw new ArgumentNullException("head");
}
return(LinqEnumerable.Concat(head, LinqEnumerable.Repeat(tail, 1)));
}
/// <summary>
/// Prepends a single value to a sequence.
/// </summary>
public static IEnumerable <TSource> Prepend <TSource>(this IEnumerable <TSource> source, TSource value)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
return(LinqEnumerable.Concat(LinqEnumerable.Repeat(value, 1), source));
}
public void Solve()
{
int N = Reader.Int(), M = Reader.Int(), S = Reader.Int() - 1;
var E = Enu.Range(0, N).Select(i => new List <int>()).ToArray();
for (int i = 0; i < M; i++)
{
int a = Reader.Int() - 1, b = Reader.Int() - 1;
E[a].Add(b);
E[b].Add(a);
}
var maxMinV = Enu.Repeat(-1, N).ToArray();
maxMinV[S] = S;
var heap = new Heap <long>(true);
heap.Push(((long)S << 32) + S);
while (heap.Count > 0)
{
long mask = heap.Pop();
int val = (int)(mask >> 32);
int at = (int)mask;
if (val < maxMinV[at])
{
continue;
}
foreach (int next in E[at])
{
int nextVal = Math.Min(next, val);
if (nextVal > maxMinV[next])
{
maxMinV[next] = nextVal;
heap.Push(((long)nextVal << 32) + next);
}
}
}
Console.SetOut(new StreamWriter(Console.OpenStandardOutput())
{
AutoFlush = false
});
for (int i = 0; i < N; i++)
{
if (maxMinV[i] >= i)
{
Console.WriteLine(i + 1);
}
}
Console.Out.Flush();
}
public void Solve()
{
int N = Reader.Int(), M = Reader.Int(), S = Reader.Int() - 1;
var E = Enu.Range(0, N).Select(i => new List <int>()).ToArray();
for (int i = 0; i < M; i++)
{
int a = Reader.Int() - 1, b = Reader.Int() - 1;
E[a].Add(b);
E[b].Add(a);
}
var maxMinV = Enu.Repeat(-1, N).ToArray();
maxMinV[S] = S;
var que = new Queue <int>();
var inQue = new bool[N];
que.Enqueue(S);
while (que.Count > 0)
{
int at = que.Dequeue();
inQue[at] = false;
foreach (int next in E[at])
{
int nextVal = Math.Min(next, maxMinV[at]);
if (nextVal > maxMinV[next])
{
maxMinV[next] = nextVal;
if (!inQue[next])
{
inQue[next] = true; que.Enqueue(next);
}
}
}
}
Console.SetOut(new StreamWriter(Console.OpenStandardOutput())
{
AutoFlush = false
});
for (int i = 0; i < N; i++)
{
if (maxMinV[i] >= i)
{
Console.WriteLine(i + 1);
}
}
Console.Out.Flush();
}
public static void Main()
{
var hw = Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray();
var h = hw[0];
var w = hw[1];
var grid = new int[h + 2][];
grid[0] = grid[h + 1] = E.Repeat(-1, w + 2).ToArray();
for (int i = 1; i < grid.Length - 1; i++)
{
grid[i] = Console.ReadLine().Split().Select(x => int.Parse(x)).Prepend(int.MinValue).Append(int.MinValue).ToArray();
}
var k = 0;
var steps = new System.Text.StringBuilder();
var sy = 1;
var sx = 1;
var dy = new [] { 0, 1, 0, -1 };
var dx = new [] { 1, 0, -1, 0 };
var d = 0;
while (true)
{
if (grid[sy + dy[d]][sx + dx[d]] < 0)
{
d = (d + 1) % dy.Length;
if (grid[sy + dy[d]][sx + dx[d]] < 0)
{
break;
}
}
var ty = sy + dy[d];
var tx = sx + dx[d];
if (grid[sy][sx] % 2 == 1)
{
k++;
steps.AppendLine($"{sy} {sx} {ty} {tx}");
grid[ty][tx]++;
}
grid[sy][sx] = int.MinValue;
sy = ty;
sx = tx;
}
Console.WriteLine(k);
Console.Write(steps);
}
void Dijkstra()
{
var q = new Heap <State>();
q.Push(new State(0, 0, 0));
Func <int, int, int> Get = (v, used) => MinCost[v][used - MinUsed[v]];
Action <int, int, int> Update = (v, used, cost) =>
{
if (used - MinUsed[v] >= MinCost[v].Length)
{
return;
}
if (CheckMin(ref MinCost[v][used - MinUsed[v]], cost))
{
q.Push(new State(v, used, cost));
}
};
while (q.Count > 0)
{
var s = q.Pop();
int a = s.v, used = s.used, cost = s.cost;
if (cost > Get(a, used))
{
continue;
}
foreach (int b in E1[a])
{
Update(b, used, cost + 1);
}
foreach (int b in E2[a])
{
Update(b, used + 1, cost + used + 1);
}
}
Ans = Enu.Repeat(INF, N).ToArray();
for (int i = 0; i < N; i++)
{
foreach (int v in MinCost[i])
{
CheckMin(ref Ans[i], v);
}
}
}
void Dijkstra()
{
var q = new MinHeap();
q.Push(0);
Action <int, int, int> Update = (v, used, cost) =>
{
if (used - MinUsed[v] >= MinCost[v].Length)
{
return;
}
if (CheckMin(ref MinCost[v][used - MinUsed[v]], cost))
{
q.Push(Compress(v, used, cost));
}
};
while (q.Count > 0)
{
var key = q.Pop();
int a, used, cost;
Decompress(key, out a, out used, out cost);
if (cost > MinCost[a][used - MinUsed[a]])
{
continue;
}
foreach (int b in E1[a])
{
Update(b, used, cost + 1);
}
foreach (int b in E2[a])
{
Update(b, used + 1, cost + used + 1);
}
}
Ans = Enu.Repeat(INF, N).ToArray();
for (int i = 0; i < N; i++)
{
foreach (int v in MinCost[i])
{
CheckMin(ref Ans[i], v);
}
}
}
public void Solve()
{
N = Reader.Int();
G = EdgeRead(N);
K = Reader.Int();
Val = new int[N];
MinVal = Enu.Repeat(-INF, N).ToArray();
MaxVal = Enu.Repeat(INF, N).ToArray();
for (int i = 0; i < K; i++)
{
int at = Reader.Int() - 1;
Val[at] = MinVal[at] = MaxVal[at] = Reader.Int();
}
if (!DFS(0, -1) || !GenAnswer(0, -1))
{
Console.WriteLine("No"); return;
}
Console.WriteLine("Yes\n" + string.Join("\n", Val));
}
public void Solve()
{
int X1 = Reader.Int(), Y1 = Reader.Int(), X2 = Reader.Int(), Y2 = Reader.Int();
int N = Reader.Int();
int[] X = new int[N], Y = new int[N];
int num = 0;
for (int i = 0; i < N; i++)
{
int x = Reader.Int(), y = Reader.Int();
if (x < Math.Min(X1, X2) || x > Math.Max(X1, X2))
{
continue;
}
if (y < Math.Min(Y1, Y2) || y > Math.Max(Y1, Y2))
{
continue;
}
X[num] = X1 <= X2 ? x : -x;
Y[num] = Y1 <= Y2 ? y : -y;
num++;
}
Array.Resize(ref X, num); Array.Resize(ref Y, num);
Array.Sort(X, Y);
var DP = Enu.Repeat(int.MaxValue, num + 1).ToArray();
foreach (int y in Y)
{
DP[LowerBound(DP, y)] = y;
}
int circles = LowerBound(DP, int.MaxValue);
double ans = (Math.Abs(X1 - X2) + Math.Abs(Y1 - Y2)) * 100L - circles * (20 - 5 * Math.PI);
if (circles == Math.Min(Math.Abs(X1 - X2), Math.Abs(Y1 - Y2)) + 1)
{
ans += 5 * Math.PI;
}
Console.WriteLine(ans);
}
public static void Main()
{
var n = int.Parse(Console.ReadLine());
var dp = new long[2][];
dp[0] = E.Repeat(1L, 1 << 6).ToArray();
dp[1] = new long[dp[0].Length];
dp[0][A << 4 | G << 2 | C] = 0;
dp[0][A << 4 | C << 2 | G] = 0;
dp[0][G << 4 | A << 2 | C] = 0;
for (int i = 3; i < n; i++)
{
for (int s = 0; s < dp[(i + 1) % 2].Length; s++)
{
int c3 = s >> 4 & 3;
int c2 = s >> 2 & 3;
int c1 = s >> 0 & 3;
var skipC = c2 == A && c1 == G || c2 == G && c1 == A || c3 == A && (c2 == G || c1 == G);
var skipG = c2 == A && c1 == C;
var k = dp[(i + 1) % 2][s];
dp[(i + 1) % 2][s] = 0;
for (int c0 = A; c0 < 4; c0++)
{
if (c0 == C && skipC || c0 == G && skipG)
{
continue;
}
dp[i % 2][c2 << 4 | c1 << 2 | c0] += k;
dp[i % 2][c2 << 4 | c1 << 2 | c0] %= Mod;
}
}
}
var sum = dp[(n + 1) % 2].Aggregate((x, y) => (x + y) % Mod);
Console.WriteLine(sum);
}
public void Solve()
{
N = Reader.Int();
M = Reader.Int();
E = EdgeRead(N, M);
int NQ = Reader.Int();
Q = Reader.IntTable(NQ);
foreach (var q in Q)
{
q[0]--;
}
Color = new int[N];
MaxRemDist = Enu.Repeat(-1, N).ToArray();
Array.Reverse(Q);
foreach (var q in Q)
{
BFS(q[0], q[1], q[2]);
}
Console.WriteLine(string.Join("\n", Color));
}
/// <summary>
/// Generates a sequence that contains one repeated value.
/// </summary>
/// <typeparam name="TResult">Result sequence element type.</typeparam>
/// <param name="element">The value to be repeated.</param>
/// <param name="count">The number of times to repeat the value in the generated sequence.</param>
/// <returns>Sequence that contains a repeated value.</returns>
public static IEnumerable <TResult> Repeat <TResult>(TResult element, int count)
{
return(Enumerable.Repeat <TResult>(element, count));
}
public static IEnumerable <T> Return <T>(T value)
{
return(Enumerable.Repeat(value, 1));
}
private static Writer <ListMonoid <Entry>, Entry, List <Maybe <Packet> > > GroupSame(
ListMonoid <Entry> initial,
Func <ListMonoid <Entry>, ListMonoid <Entry>, Writer <ListMonoid <Entry>, Entry, ListMonoid <Entry> > > merge,
List <Packet> packets,
Func <Packet, Writer <ListMonoid <Entry>, Entry, Maybe <Packet> > > fn)
{
if (!packets.Any())
{
return(from _ in WriterEntries.Tell(initial)
select new List <Maybe <Packet> >());
}
var x = packets.First();
var xs = packets.Skip(1).ToList();
return(from tuple in WriterEntries.Return(fn(x).RunWriter)
let result = tuple.Item1
let output = tuple.Item2
let localxs = xs
let localfn = fn
let localinitial = initial
from @new in merge(localinitial, output)
from rest in GroupSame(@new, merge, localxs, localfn)
select Enumerable.Repeat(result, 1).Concat(rest).ToList());
}
public static IEnumerable <TResult> Repeat <TResult>(TResult element, int count) => LinqEnumerable.Repeat(element, count);
