# Help needed in Wormholes (ZCO12002)!

Problem: Wormholes

My Solution: 70/100 Partial AC

``````#include <bits/stdc++.h>

using namespace std;

#define scin(a) scanf("%d",&(a))
#define prin(a) printf("%d",(a))

int main() {
int N, X, Y;
scin(N);
scin(X);
scin(Y);
vector<int> V(X), W(Y);
vector<pair<int, int>> cont(N);
for (int i = 0; i < N; i++)
scanf("%d %d", &cont[i].first, &cont[i].second);
for (int i = 0; i < X; i++)
scin(V[i]);
for (int i = 0; i < Y; i++)
scin(W[i]);
sort(V.begin(), V.end());
sort(W.begin(), W.end());
int mn = INT_MAX, start, end, v, w;
for (auto i:cont) {
start = i.first;
end = i.second;
if (lower_bound(W.begin(), W.end(), end) != W.end())
w = *lower_bound(W.begin(), W.end(), end);
auto vIter = upper_bound(V.begin(), V.end(), start);
if (vIter == V.end() || vIter == V.begin())
continue;
else
--vIter;
v = *vIter;
mn = min(mn, abs(w - v) + 1);
}
prin(mn);
return 0;
}
``````

My approach:

I sort the entering and exiting wormholes according to time.
Then for each contest, I check for the minimum time possible. I fail in two sub-tasks, but I canâ€™t figure out why!

Arnav

Try this:

``````2 2 1
5 10
11 12
5 11
12
``````
2 Likes

I agree with the comment above

You could comment such things instead of answering: â€śI agree with the comment aboveâ€ť, â€śvery interestingâ€ť etc.

I understood what you were wanting to point out, but how could I fix it?

Youâ€™ll have to write your own binary search. Once you do that, run your code on this:

``````2 3 1
5 10
11 12
5 11 12
11
``````

Thereâ€™s a certain minimum karma one needs to have before being able to comment.

2 Likes

Hiâ€¦ I am getting WA on only 4th test case. I tried this input and it is giving me 2 as the answer which I think is correct.

code:

``````import java.io.Writer;
import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.*;
import java.io.*;
import java.math.*;

class Codechef{

static class ProblemSolver{
static int getLowerBound(int ar[], int target){
if(target<ar[0]) return -1;
if(target==ar[0]) return ar[0];
if(target==ar[ar.length-1]) return ar[ar.length-1];
int left=0, right=ar.length-1, mid=0;
while(left<right){
// System.out.println("LOWER----------");
mid=(left+right)/2;
if(ar[mid]==target) return target;
if(ar[mid]<target){
left=mid+1;
// System.out.println("right: "+right+" left: "+left+" mid: "+mid);
}
else if(ar[mid]>target){
if(ar[mid-1]<=target) return ar[mid-1];
right=mid;
// System.out.println("right: "+right+" left: "+left+" mid: "+mid);        }
}
}
return ar[mid];
}
static int getUpperBound(int ar[], int target){
if(target==ar[0]) return ar[0];
if(target==ar[ar.length-1]) return ar[ar.length-1];
if(target>ar[ar.length-1]) return -1;
int left=0, right=ar.length-1, mid=0;
while(left<right){
// System.out.println("UPPER----------");
mid=(left+right)/2;
if(ar[mid]==target) return ar[mid];
if(ar[mid]<target){
if(ar[mid+1]>=target) return ar[mid+1];
left=mid+1;
// System.out.println("right: "+right+" left: "+left+" mid: "+mid);
}
else if(ar[mid]>target){
right=mid;
// System.out.println("right: "+right+" left: "+left+" mid: "+mid);
}
}
return ar[mid];
}
static class interval{
int start, end;
interval(int a, int b){
start=a;
end=b;
}
public String toString(){
return "(start: "+start+"  end:  "+end+")\n";
}
}
static class mycomp implements Comparator<interval>{
public int compare(interval i1, interval i2){
int d1= i1.end-i1.start;
int d2= i2.end-i2.start;
return (d1>d2)? 1:-1;
}
}
public void solveTheProblem(InputReader in,OutputWriter out, NumberTheory nt){
int test=1;//in.nextInt();
while(test-- >0){
PriorityQueue<interval> pq= new PriorityQueue<>(new mycomp());
// int ar[]={10, 20};
// System.out.println(getLowerBound(ar, 20));
int n, x, y;
n=in.nextInt();
x=in.nextInt();
y=in.nextInt();
for(int i=0;i<n;i++){
interval ii= new interval(in.nextInt(), in.nextInt());
}
// System.out.println("---"+pq);
int start[]= new int[x];
int end[]= new int[y];
for(int i=0;i<x;i++)
start[i]=in.nextInt();
for(int i=0;i<y;i++)
end[i]=in.nextInt();
Arrays.sort(start);
Arrays.sort(end);
int min=Integer.MAX_VALUE;
for(int i=0;i<n;i++){
interval ii= pq.poll();
// System.out.println("interval: "+ii);
int a, b;
a=getLowerBound(start, ii.start);
b=getUpperBound(end, ii.end);
if(a!=-1 && b!=-1)
min=Math.min(min, (b-a)+1);
// System.out.println("start: "+a+" end: "+b+" diff: "+(b-a+1)+" min: "+min );
}
System.out.println(min);
}
}
}

public static void main(String[] args){
InputStream inputStream=System.in;
OutputStream outputStream=System.out;
OutputWriter out=new OutputWriter(outputStream);
NumberTheory nt= new NumberTheory();
ProblemSolver problemSolver=new ProblemSolver();
problemSolver.solveTheProblem(in,out, nt);
out.flush();
out.close();
}

private boolean finished = false;

private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;

this.stream = stream;
}

if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}

public int peek() {
if (numChars == -1) {
return -1;
}
if (curChar >= numChars) {
curChar = 0;
try {
} catch (IOException e) {
return -1;
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar];
}

public int nextInt() {
while (isSpaceChar(c)) {
}
int sgn = 1;
if (c == '-') {
sgn = -1;
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
} while (!isSpaceChar(c));
return res * sgn;
}

public long nextLong() {
while (isSpaceChar(c)) {
}
int sgn = 1;
if (c == '-') {
sgn = -1;
}
long res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
} while (!isSpaceChar(c));
return res * sgn;
}

public String nextLine() {
while (isSpaceChar(c)) {
}
StringBuilder res = new StringBuilder();
do {
if (Character.isValidCodePoint(c)) {
res.appendCodePoint(c);
}
} while (!isSpaceChar(c));
return res.toString();
}

public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}

public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}

StringBuilder buf = new StringBuilder();
while (c != '\n' && c != -1) {
if (c != '\r') {
buf.appendCodePoint(c);
}
}
return buf.toString();
}

while (s.trim().length() == 0) {
}
return s;
}

if (ignoreEmptyLines) {
} else {
}
}

try {
return new BigInteger(nextLine());
} catch (NumberFormatException e) {
throw new InputMismatchException();
}
}

public char nextCharacter() {
while (isSpaceChar(c)) {
}
return (char) c;
}

public double nextDouble() {
while (isSpaceChar(c)) {
}
int sgn = 1;
if (c == '-') {
sgn = -1;
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, nextInt());
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
}
if (c == '.') {
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, nextInt());
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
m /= 10;
res += (c - '0') * m;
}
}
return res * sgn;
}

public boolean isExhausted() {
int value;
while (isSpaceChar(value = peek()) && value != -1) {
}
return value == -1;
}

public String next() {
return nextLine();
}

public SpaceCharFilter getFilter() {
return filter;
}

public void setFilter(SpaceCharFilter filter) {
this.filter = filter;
}

public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
public int[] nextIntArray(int n){
int[] array=new int[n];
for(int i=0;i<n;++i)array[i]=nextInt();
return array;
}
public int[] nextSortedIntArray(int n){
int array[]=nextIntArray(n);
Arrays.sort(array);
return array;
}
public ArrayList<Integer> nextIntArrayList(int n){
ArrayList<Integer> ar= new ArrayList<>();
for(int i=0;i<n;i++)
return ar;
}
public ArrayList<Long> nextLongArrayList(int n){
ArrayList<Long> ar= new ArrayList<>();
for(int i=0;i<n;i++)
return ar;
}

public int[] nextSumIntArray(int n){
int[] array=new int[n];
array[0]=nextInt();
for(int i=1;i<n;++i)array[i]=array[i-1]+nextInt();
return array;
}
public long[] nextLongArray(int n){
long[] array=new long[n];
for(int i=0;i<n;++i)array[i]=nextLong();
return array;
}
public long[] nextSumLongArray(int n){
long[] array=new long[n];
array[0]=nextInt();
for(int i=1;i<n;++i)array[i]=array[i-1]+nextInt();
return array;
}
public long[] nextSortedLongArray(int n){
long array[]=nextLongArray(n);
Arrays.sort(array);
return array;
}
public int[][] nextIntMatrix(int n,int m){
int[][] matrix=new int[n][m];
for(int i=0;i<n;++i)
for(int j=0;j<m;++j)
matrix[i][j]=nextInt();
return matrix;
}

public int[][] nextIntMatrix(int n){
return nextIntMatrix(n,n);
}

public long[][] nextLongMatrix(int n,int m){
long[][] matrix=new long[n][m];
for(int i=0;i<n;++i)
for(int j=0;j<m;++j)
matrix[i][j]=nextLong();
return matrix;
}

public long[][] nextLongMatrix(int n){
return nextLongMatrix(n,n);
}

public char[][] nextCharMatrix(int n,int m){
char[][] matrix=new char[n][m];
for(int i=0;i<n;++i)
matrix[i]=next().toCharArray();
return matrix;
}

public char[][] nextCharMatrix(int n){
return nextCharMatrix(n,n);
}
}

static class OutputWriter {
private final PrintWriter writer;

public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}

public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}

// public void print(char[] array) {
//     writer.print(array);
// }

public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(objects[i]);
}
}

public void print(int[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(double[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(long[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(char[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(String[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(int[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void print(double[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void print(long[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void print(char[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void print(String[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void println(int[] array) {
print(array);
writer.println();
}

public void println(double[] array) {
print(array);
writer.println();
}

public void println(long[] array) {
print(array);
writer.println();
}

// public void println(char[] array) {
//     print(array);
//     writer.println();
// }

public void println(String[] array) {
print(array);
writer.println();
}

public void println() {
writer.println();
}

public void println(Object... objects) {
print(objects);
writer.println();
}

public void print(char i) {
writer.print(i);
}

public void println(char i) {
writer.println(i);
}

public void println(char[] array) {
writer.println(array);
}

public void printf(String format, Object... objects) {
writer.printf(format, objects);
}

public void close() {
writer.close();
}

public void flush() {
writer.flush();
}

public void print(long i) {
writer.print(i);
}

public void println(long i) {
writer.println(i);
}

public void print(int i) {
writer.print(i);
}

public void println(int i) {
writer.println(i);
}

public void separateLines(int[] array) {
for (int i : array) {
println(i);
}
}
}
static class NumberTheory{

/**
* Modular Arithmetic:
*  1. (a+b)%c=(a%c+b%c)%c
*  2. (a*b)%c=(a%c*b%c)%c
*  3. (a-b)%c=(a%c-b%c+c)%c
*  4. (a/b)%c=(a%c*(b^-1)%c)%c -- (b^-1 is multiplicative modulo inverse)
*/
public int modularAddition(int a,int b,int MOD){
return (a%MOD+b%MOD)%MOD;
}
public long modularAddition(long a,long b,long MOD){
return (a%MOD+b%MOD)%MOD;
}
//Modular Multiplication
public int modularMultiplication(int a,int b,int MOD){
return ((a%MOD)*(b%MOD))%MOD;
}
public long modularMultiplication(long a,long b,long MOD){
return ((a%MOD)*(b%MOD))%MOD;
}
//Modular Subtraction
public int modularSubtraction(int a,int b,int MOD){
return (a%MOD-b%MOD+MOD)%MOD;
}
public long modularSubtraction(long a,long b,long MOD){
return (a%MOD-b%MOD+MOD)%MOD;
}

/**
* Binary Exponentiation
*/
public int binaryExponentiation(int x,int n){
if(n==0)return 1;
else if(n%2==0)return binaryExponentiation(x*x,n/2);
else return x*binaryExponentiation(x*x,(n-1)/2);
}
public long binaryExponentiation(long x,long n){
long result=1;
while(n>0){
if(n%2==1)result*=x;
x=x*x;
n/=2;
}
return result;
}

/**
* Modular Exponentiation
*/
public int modularExponentiation(int x,int n,int MOD){
if(n==0)return 1%MOD;
else if(n%2==0)return modularExponentiation(modularMultiplication(x,x,MOD),n/2,MOD);
else return modularMultiplication(x,modularExponentiation(modularMultiplication(x,x,MOD),(n-1)/2,MOD),MOD);
}
public long modularExponentiation(long x,long n,long MOD){
long result=1;
while(n>0){
if(n%2==1)result=modularMultiplication(result,x,MOD);
x=modularMultiplication(x,x,MOD);
n/=2;
}
return result;
}

/**
* Factorial of a number
*/
public long factorials(long n){
if(n==0)return 1;
return n*factorials(n-1);
}

/**
* Prime factors of a number
*/
public ArrayList<Integer> distinctPrimeFactors(int n){
ArrayList<Integer> factorials=new ArrayList<>();
int limit=(int)Math.sqrt(n);
if(n%2==0){
while(n%2==0)n/=2;
}
for(int i=3;i<=limit;i+=2){
if(n%i==0){
while(n%i==0)n/=i;
}
}
return factorials;
}

public ArrayList<Long> distinctPrimeFactors(long n){
ArrayList<Long> factorials=new ArrayList<>();
long limit=(long)Math.sqrt(n);
if(n%2==0){
while(n%2==0)n/=2;
}
for(long i=3;i<=limit;i+=2){
if(n%i==0){
while(n%i==0)n/=i;
}
}
return factorials;
}

public ArrayList<Integer> primeFactors(int n){
ArrayList<Integer> factorials=new ArrayList<>();
int limit=(int)Math.sqrt(n);
if(n%2==0){
while(n%2==0)n/=2;
}
for(int i=3;i<=limit;i+=2){
if(n%i==0){
while(n%i==0)n/=i;
}
}
return factorials;
}

public ArrayList<Long> primeFactors(long n){
ArrayList<Long> factorials=new ArrayList<>();
long limit=(long)Math.sqrt(n);
if(n%2==0){
while(n%2==0)n/=2;
}
for(long i=3;i<=limit;i+=2){
if(n%i==0){
while(n%i==0)n/=i;
}
}
return factorials;
}

/**
* Combination: nCr
*/
//Naive version
//(n,r)=(n-1,r-1)+(n-1,r) for r!=0 or r!=n
//(n,0)=(n,n)=1
public int binomialCoefficientRecursive(int n,int k){
if(k==0 || k==n)return 1;//base case
return binomialCoefficientRecursive(n-1,k-1)+binomialCoefficientRecursive(n-1,k);//recursion
}

//Dynamic Programming version(Uses bottom up approach to fill the table)
//Time complexity: O(n*k)
//Space complexity: O(n*k)
public long binomialCoefficientIterative(int n,int k){
long[][] C=new long[n+1][k+1];
for(int i=0;i<=n;++i){
for(int j=0;j<=Math.min(n,k);++j){
if(j==0 || j==i)C[i][j]=1;
else C[i][j]=C[i-1][j-1]+C[i-1][j];
}
}
return C[n][k];
}

//Pascal's Triangle version(Space efficient program)
//Time complexity: O(n*k)
//Space complexity: O(k)
public long nCr(int n,int r){
int[] C=new int[r+1];
C[0]=1;//nC0=1
for(int i=1;i<=n;++i)
for(int j=Math.min(i,r);j>0;--j)
C[j]=C[j]+C[j-1];
return C[r];
}

/**
* Catlan number:
*  - Time complexity: O(n*n)
*  - Auxiliary space: O(n)
*
*  NOTE: Time complexity could be reduced to O(n) but it is
*        possible if and only if n is small or else there is
*        a chance of getting an overflow. To decrease the time
*        complexity to O(n) just remember nCr=nCn-r
*/
public long catlanNumber(int n){
long[] catlan=new long[n+1];
catlan[0]=catlan[1]=1;
for(int i=2;i<=n;++i)
for(int j=0;j<i;++j)
catlan[i]+=catlan[j]*catlan[i-1-j];

return catlan[n];
}

/**
* Greatest Common Divisor(GCD)
*  - It is also known as Highest Common Factor(HCF)
*  - Time complexity: log(min(a,b))
*  - Auxiliary Space: O(1)
*/
public int gcd(int a,int b){
if(b==0)return a;
return gcd(b,a %b);
}

public long gcd(long a,long b){
if(b==0)return a;
return gcd(b,a%b);
}

/**
* Extended Euclid's Algorithm:
*  - ax+by=gcd(a,b)
*  - Time complexity:
*  -
*/

/**
* Least Common Multiple(LCM):
*  - Time complexity: log(min(a,b))
*  - Auxiliary Space: O(1)
*/
public long lcm(long a,long b){
return (a*b)/gcd(a,b);
}

}
}

``````

My approach:

1. sort the contest by their end_time-start_time;1
2. for every contest get the lower bound from starting wormhole and upper bound from ending wormhole.
3. ans is the minimum of these differences.

Thank you.
This testcase helped me find the bug in my code.

#include<bits/stdc++.h>
#include
using namespace std;

int main() {
long long int a,b,c;
cin>>a>>b>>c;
vector<pair <long long int,long long int>> V(a);
vector X(b);
long long int q;
for(long long int i=0;i<a;i++)
{
cin>>V[i].first>>V[i].second;
//=q-V[i].first;
}
for(long long int i=0;i<b;i++)
{
cin>>X[i];
}
for(long long int i=0;i<c;i++)
{
cin>>Y[i];
}
// sort(V.begin(), V.end(), sortbysec);
sort(X.begin(),X.end());
sort(Y.begin(),Y.end());
long long int TT,CW,MW=INT_MAX,WA,WB;
//currentwait minwait waitbefore waitafter
for(long long int i=0;i<a;i++)
{ if(V[i].first-V[i].second >= MW)
{
continue;
}
long long int j=0;
WB=V[i].first-X[j];
while(X[j]<=V[i].first && j<b)
{ WB=V[i].first-X[j];
j++;
}

``````j=0;
while(Y[j]<V[i].second &&  j<c)
{
j++;
}
WA=Y[j]-V[i].second;
if(WA<0||WB<0)
{
continue;
}
else{
CW=1+(V[i].second-V[i].first)+WA+WB;
}
// cout<<V[i].second<<" "<<WA<<" "<<WB<<" "<<CW<<endl;
if(CW<MW)
{
MW=CW;
}
``````

}
cout<<MW;