Codejam 2020 Qualification Round Problem 3... What's wrong with the logic?

The way I approached was to create 3 arrays: one for starting time of each event, one for ending time, and one for a possible distribution of tasks. I reset the third array to contain 'x' for every element. Then I first assign all possible tasks to Cameron by checking if a task overlaps with any previously assigned task using this logic:

• If (starting time of new task < starting time of assigned task AND ending time of new task <= starting time of assigned task) OR (starting time of new task >= ending time of new task AND ending time of new task > ending time of assigned task) THEN this new task doesn't overlap and can be assigned to Cameron.

I then follow a similar logic to assign tasks to Jamie. Then I print IMPOSSIBLE if there is one of more empty slots, else the answer. Please check the code:

import java.lang.*;
import java.util.*;
import java.io.*;

public class Solution {
  
    
    public static void main (String [] args){
        
        //Scanner
        Scanner input = new Scanner(System.in);
        
        
        int T = input.nextInt();    //test cases
        
        for(int i=0; i<T; i++){
            
            int x = i+1;    //test case number
            int N = input.nextInt();
            
            
            int [] S = new int [N];     //start time
            int [] E = new int [N];     //end time
            char [] y = new char [N];   //answer

            char C = 'C';   //Cameron
            char J = 'J';   //Jamie
            int flag = 0;   //1 if impossible
            
            
            for(int j=0; j<N; j++)  //setting all slots to x
                y[j] = 'x';
            
            for(int j=0; j<N; j++){     //taking input
                S[j] = input.nextInt();
                E[j] = input.nextInt();
            }
            
            y[0] = C;   //assigning C to first task
            
            for(int j=1; j<N; j++){ //assigning rest of C's
                for(int k=0; k<j; k++){
                    
                    if(y[k] == C){
                        if((S[j]<S[k] && E[j]<= S[k]) || (S[j]>=E[k] && E[j]> E[k])){
                            y[j] = C;
                        }
                        else{
                            y[j] = 'x';
                            break;
                        }
                    }
                }
            }
            
            
            for(int j=1; j<N; j++){     //assigning J to first empty slot 
                if(y[j] == 'x'){
                    y[j] = J;
                    break;
                }
            }
            
            for(int j=1; j<N; j++){     //assigning rest of J's
                if(y[j] == 'x'){
                    for(int k=0; k<j; k++){
                    
                        if(y[k] == J){
                            if((S[j]<S[k] && E[j]<= S[k]) || (S[j]>=E[k] && E[j]> E[k])){
                                y[j] = J;
                            }
                            else{
                                y[j] = 'x';
                                break;
                            }
                        }
                    }
                }
                
            }
            
            for(int j=0; j<N; j++){     //Check if there is empty slot
                if(y[j] == 'x'){
                    flag = 1;
                    break;
                }
            }
            String Y = "";  //Answer
            
            if(flag == 1){
                Y = "IMPOSSIBLE";
                System.out.println("Case #" + x + ": " + Y);
            }
                
            else{
                for(int j=0; j<N; j++)
                    Y += y[j];
                
                System.out.println("Case #" + x + ": " + Y );
            }
        }
    }
}

I keep getting a WA for some reason. Why is the logic incorrect?

instead of creating 3 arrays, you should create many arrays with 3 elements each, (starttime, endtime, entryindex). Then sort these arrays according to starttime. This is a unweighted interval scheduling problem, you can have a look at the description here:http://www.cse.psu.edu/~ads22/courses/cmpsc465/S12/lec-notes/CMPSC465-S12-Lec-17-greedy-algs.pptx.pdf