GroceryStore coding task - Learn to Code

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

int solution(int A[], int M, int B[], int M2, int C[], int M3, int D[], int N);

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

int solution(vector<int> &A, vector<int> &B, vector<int> &C, vector<int> &D);

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

int solution(vector<int> &A, vector<int> &B, vector<int> &C, vector<int> &D);

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

class Solution { public int solution(int[] A, int[] B, int[] C, int[] D); }

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

int solution(List<int> A, List<int> B, List<int> C, List<int> D);

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

func Solution(A []int, B []int, C []int, D []int) int

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

class Solution { public int solution(int[] A, int[] B, int[] C, int[] D); }

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

class Solution { public int solution(int[] A, int[] B, int[] C, int[] D); }

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

function solution(A, B, C, D);

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

fun solution(A: IntArray, B: IntArray, C: IntArray, D: IntArray): Int

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

function solution(A, B, C, D)

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

int solution(NSMutableArray *A, NSMutableArray *B, NSMutableArray *C, NSMutableArray *D);

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

function solution(A: array of longint; M: longint; B: array of longint; M2: longint; C: array of longint; M3: longint; D: array of longint; N: longint): longint;

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

function solution($A, $B, $C, $D);

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

sub solution { my ($A, $B, $C, $D) = @_; my @A = @$A; my @B = @$B; my @C = @$C; my @D = @$D; ... }

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

def solution(A, B, C, D)

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

def solution(a, b, c, d)

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

object Solution { def solution(a: Array[Int], b: Array[Int], c: Array[Int], d: Array[Int]): Int }

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

public func solution(_ A : inout [Int], _ B : inout [Int], _ C : inout [Int], _ D : inout [Int]) -> Int

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

function solution(A: number[], B: number[], C: number[], D: number[]): number;

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

Du bist hungrig — aber dein Kühlschrank ist leer. Daher machst du dich auf den Weg, in einem der benachbarten Läden etwas zu Essen zu besorgen. Du solltest dich jedoch beeilen, da einige der Läden demnächst schließen werden.

Deine Nachbarschaft besteht aus N Plätzen die durch M Straßen direkt verbunden sind. Die Plätze sind von 0 bis N − 1 durchnummeriert und an jedem Platz befindet sich ein Laden. Du selber wohnst am Platz 0 und kannst diesen auch in 0 Sekunden erreichen. Als Karte für deine Nachbarschaft bekommst du vier Arrays A, B, C und D (Indizierung beginnt jeweils bei 0). Die Arrays A, B und C enthalten jeweils M Integer, D enthält N Integer.

Die Zeit um den Weg zwischen A[I] und B[I] zurückzulegen (für jedes 0 ≤ I < M) beträgt C[I] Sekunden (in beide Richtungen).

Es kann zwischen zwei Plätzen auch mehrere Straßen geben, oder Straßen, die am gleichen Platz beginnen und enden.

Straßen können sich kreuzen, man kann dort aber nicht von der einen auf die andere wechseln (d.h. der Graph der Straßen und Plätze ist nicht zwingend planar).

Es kann sein, dass du nicht alle Plätze erreichen kannst.

Ein Laden am Platz J schließt in D[J] Sekunden (0 ≤ J < N). Sollte D[J] = −1 sein, so ist der Laden bereits geschlossen.
Es genügt einen Laden in der letzen Sekunde vor der Schließung zu erreichen, um noch einzukaufen.

Schreibe eine Funktion:

Private Function solution(A As Integer(), B As Integer(), C As Integer(), D As Integer()) As Integer

die, gegeben die Arrays A, B, C und D, die minimale Zeit berechnet (und zurückgibt), die es braucht einen geöffneten Laden zu erreichen. Wenn dies nicht möglich ist, muss −1 zurückgegeben werden.

Ein Beispiel: Gegeben seien:

A[0] = 0 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 B[0] = 1 B[1] = 2 B[2] = 2 B[3] = 3 B[4] = 0 B[5] = 1 C[0] = 2 C[1] = 3 C[2] = 4 C[3] = 5 C[4] = 7 C[5] = 5 D[0] = -1 D[1] = 1 D[2] = 3 D[3] = 8

Die Funktion sollte hier 7 zurückgeben, was der kürzesten Zeit zu einem offenen Shop entspricht. Der Weg zu diesem ist 0 −> 1 −> 3.

Während für:

A[0] = 0 B[0] = 1 C[0] = 10 D[0] = -1 D[1] = 6 D[2] = 8

−1 zurückgegeben werden muss, denn Platz 1 kann man nicht in weniger als 10 Sekunden erreichen und Platz 2 ist vollständig unerreichbar.

Folgende Annahmen können getroffen werden:

M ist ein Integer im Intervall [0,10⁴]

N ist ein Integer im Intervall [0,100]

jedes Element von A ist ein Integer im Intervall [0,99]

jedes Element von B ist ein Integer im Intervall [0,99]

jedes Element von C ist ein Integer im Intervall [0,10⁵]

jedes Element von D ist ein Integer im Intervall [−1,10⁹]

Komplexität:

Die erwartete worst−case Zeitkomplexität ist O(N²).

Die erwartete worst−case Speicherplatzkomplexität ist O(N²), ohne Berücksichtung des Platzbedarfs der Argumente.

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

int solution(int A[], int M, int B[], int M2, int C[], int M3, int D[], int N);

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

int solution(vector<int> &A, vector<int> &B, vector<int> &C, vector<int> &D);

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

int solution(vector<int> &A, vector<int> &B, vector<int> &C, vector<int> &D);

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

class Solution { public int solution(int[] A, int[] B, int[] C, int[] D); }

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

int solution(List<int> A, List<int> B, List<int> C, List<int> D);

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

func Solution(A []int, B []int, C []int, D []int) int

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

class Solution { public int solution(int[] A, int[] B, int[] C, int[] D); }

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

class Solution { public int solution(int[] A, int[] B, int[] C, int[] D); }

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

function solution(A, B, C, D);

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

fun solution(A: IntArray, B: IntArray, C: IntArray, D: IntArray): Int

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

function solution(A, B, C, D)

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

int solution(NSMutableArray *A, NSMutableArray *B, NSMutableArray *C, NSMutableArray *D);

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

function solution(A: array of longint; M: longint; B: array of longint; M2: longint; C: array of longint; M3: longint; D: array of longint; N: longint): longint;

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

function solution($A, $B, $C, $D);

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

sub solution { my ($A, $B, $C, $D) = @_; my @A = @$A; my @B = @$B; my @C = @$C; my @D = @$D; ... }

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

def solution(A, B, C, D)

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

def solution(a, b, c, d)

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

object Solution { def solution(a: Array[Int], b: Array[Int], c: Array[Int], d: Array[Int]): Int }

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

public func solution(_ A : inout [Int], _ B : inout [Int], _ C : inout [Int], _ D : inout [Int]) -> Int

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

function solution(A: number[], B: number[], C: number[], D: number[]): number;

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

There is no food in your fridge and you are hungry. You want to go to a local store and buy some food. You have to hurry as some of the shops will close soon.

There are N squares in your neighborhood and M direct roads connecting them. The squares are numbered from 0 to N − 1. You are living in square 0 and can reach it in 0 seconds. The stores are located in the squares, one in each of them. You are given a map of the neighborhood in the form of four zero-indexed arrays A, B, C and D. Each of the arrays A, B, C contains M integers, while D contains N integers.

For each I (0 ≤ I < M), the walking distance between squares A[I] and B[I] is C[I] seconds (in either direction).

There can be multiple roads connecting the same pair of squares, or a road with both ends entering the same square.

It is possible that some roads go through tunnels or over bridges (that is, the graph of squares and roads doesn't have to be planar).

It is not guaranteed that you are able to reach all the squares.

For each J (0 ≤ J < N), the shop at square J will close in D[J] seconds (if D[J] = −1, then the store is already closed);
it is possible to buy the food even if you reach the shop at the very last second, when it closes.

Write a function:

Private Function solution(A As Integer(), B As Integer(), C As Integer(), D As Integer()) As Integer

that, given arrays A, B, C and D, returns the minimum time (in seconds) needed to reach an open store. If it is impossible, it should return −1.

For example, given:

A[0] = 0 B[0] = 1 C[0] = 2 D[0] = -1 A[1] = 1 B[1] = 2 C[1] = 3 D[1] = 1 A[2] = 3 B[2] = 2 C[2] = 4 D[2] = 3 A[3] = 1 B[3] = 3 C[3] = 5 D[3] = 8 A[4] = 2 B[4] = 0 C[4] = 7 A[5] = 2 B[5] = 1 C[5] = 5

the function should return 7. To reach the closest open shop you should follow the path: 0 −> 1 −> 3.

However, if given, for example:

A[0] = 0 D[0] = -1 B[0] = 1 D[1] = 6 C[0] = 10 D[2] = 8

the function should return −1, as you will not be able to reach square 1 in less than 10 seconds, and you cannot reach square 2 at all.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..120];

M is an integer within the range [0..N**2];

each element of arrays A and B is an integer within the range [0..N - 1];

each element of array C is an integer within the range [0..100,000];

each element of array D is an integer within the range [−1..1,000,000,000].

GroceryStore

Developer Training

Sign up for our newsletter:

Social: