Starfleet

                            Solution in C :

In  C++  :








#include <stdio.h>
#include <algorithm>
#include <map>
#define STEP_SIZE 5000
#define MAXN 50005
using namespace std;

int N, Q, V;
int x[MAXN], y[MAXN], F[MAXN], f[MAXN];
int fN;

map<int, int> freqCompression;

int occur[15][15][50005];
int best[15][15];
pair<int, int> fp[MAXN];

int main()
{
	scanf("%d%d%d", &N, &Q, &V);
	fN=0;
	for(int i=0; i < N; ++i){
		scanf("%d%d%d", x+i, y+i, F+i);
		if(freqCompression[F[i]] == 0)
			freqCompression[F[i]]=++fN;
		F[i]=freqCompression[F[i]]-1;
		fp[i]=make_pair(y[i], F[i]);
	}
	sort(fp, fp+N);
	for(int i=0; i < N; ++i)
		f[i]=fp[i].second;
	for(int i=0; i <= N; i += STEP_SIZE)
		for(int j=i; j <= N; j += STEP_SIZE){
			int I=i/STEP_SIZE, J=j/STEP_SIZE;
			for(int k=0; k < 50000; ++k)
				occur[I][J][k]=0;
			best[I][J]=0;
			for(int k=i; k < j; ++k){
				++occur[I][J][f[k]];
				if(occur[I][J][f[k]] > best[I][J])
					best[I][J]=occur[I][J][f[k]];
			}
		}
	for(int i=0; i < Q; ++i){
		int a, b, t;
		scanf("%d%d%d", &a, &b, &t);
		int c=lower_bound(fp, fp+N, make_pair(b, -1))-fp;
		int d=lower_bound(fp, fp+N, make_pair(a, 999999999))-fp;
		int low=c/STEP_SIZE+1, upp=d/STEP_SIZE;
		int stop=min(low*STEP_SIZE, d);
		int start=max(upp*STEP_SIZE, stop);
		if(upp<low)
			upp=low;
		int B=best[low][upp];
		for(int j=c; j < stop; ++j){
			++occur[low][upp][f[j]];
			if(occur[low][upp][f[j]] > B)
				B=occur[low][upp][f[j]];
		}
		for(int j=start; j < d; ++j){
			++occur[low][upp][f[j]];
			if(occur[low][upp][f[j]] > B)
				B=occur[low][upp][f[j]];
		}
		printf("%d\n", B);
		for(int j=c; j < stop; ++j){
			--occur[low][upp][f[j]];
		}
		for(int j=start; j < d; ++j){
			--occur[low][upp][f[j]];
		}
	}
	return 0;
}








In    Java  :









import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.TreeSet;

public class Solution {

static class Query{
HashMap<Integer,Integer> ShipFrequency;
int Answer;
int Total;
int Singletons;
public Query()
{
ShipFrequency = null;
Answer = 0;
}
public void Answer()
{
System.out.println(Answer);
}
}
static class Task{
Query Q;
boolean begin;
public Task(Query Q,boolean begin)
{
this.Q = Q;
this.begin = begin;
}
public void Do(
HashMap<Integer,Integer> HM,int Total,int Singletons)
{
if(begin)
{
Q.ShipFrequency =
 (HashMap<Integer, Integer>) HM.clone();
Q.Total = Total;
Q.Singletons = Singletons;
}
else
{
int A = 0;
int F = -1;
Iterator<Integer> It = HM.keySet().iterator();
Total -= Q.Total;
while(It.hasNext())
{
int T = It.next();
int Temp = HM.get(T)-(
Q.ShipFrequency.containsKey(T)?Q.ShipFrequency.get(T):0);
Total -= Temp;
A = Math.max(A,Temp);
if(Temp>A)
{
    A = Temp;
    F = T;
}
if(A>=Total)
{
    break;
}
}
if(A==0 && Singletons>Q.Singletons)
{
A = 1;
}
Q.Answer = A;
}
}
}

public static TreeMap<Integer,ArrayList<Integer>> Ships =
 new TreeMap<Integer,ArrayList<Integer>>();
public static int TotSing;

public static void AddToShips(int X,int F)
{
if(Ships.containsKey(X))
{
Ships.get(X).add(F);
}
else
{
ArrayList<Integer> L = new ArrayList<Integer>();
L.add(F);
Ships.put(X,L);
}
}

public static void main(String[] args) {
Scanner In = new Scanner(System.in);
int N = In.nextInt();
int Q = In.nextInt();
In.nextInt();

HashSet<Integer> Singletons = new HashSet<Integer>();
HashSet<Integer> ToRemove = new HashSet<Integer>();
for(int i=0 ; i<N ; i++)
{
In.nextInt();
int X = In.nextInt();
int F = In.nextInt();
AddToShips(X,F);
if(Singletons.contains(F))
{
ToRemove.add(F);
}
else
{
Singletons.add(F);
}
}
Iterator<Integer> it = ToRemove.iterator();
while(it.hasNext())
{ Singletons.remove(it.next()); }
TotSing = Singletons.size();
ArrayList<Query> Queries = new ArrayList<Query>();
TreeMap<Integer,ArrayList<Task>> Tasks 

= new TreeMap<Integer,ArrayList<Task>>();
for(int i=0 ; i<Q ; i++)
{
int U = In.nextInt();
int D = In.nextInt();
In.nextInt();
Query Qu = new Query();
Queries.add(Qu);
if(Tasks.containsKey(D-1))
{
Tasks.get(D-1).add(new Task(Qu,true));
}
else
{
ArrayList<Task> L = new ArrayList<Task>();
L.add(new Task(Qu,true));
Tasks.put(D-1,L);
}
if(Tasks.containsKey(U))
{
Tasks.get(U).add(new Task(Qu,false));
}
else
{
ArrayList<Task> L = new ArrayList<Task>();
L.add(new Task(Qu,false));
Tasks.put(U,L);
}
}
HashMap<Integer,Integer> Freq =
 new HashMap<Integer,Integer>();
int iSingletons = 0;
int Tot = 0;
Iterator<Integer> It = Tasks.keySet().iterator();
Iterator<Integer> It2 = Ships.keySet().iterator();
int LastShip;
LastShip = It2.next();
while(It.hasNext())
{
int TaskPos = It.next();
while(LastShip<=TaskPos)
{
Iterator<Integer> It3 = Ships.get(LastShip).iterator();
Tot += Ships.get(LastShip).size();
while(It3.hasNext())
{
int T = It3.next();
if(Freq.containsKey(T))
{
Freq.put(T,Freq.get(T)+1);
}
else if(Singletons.contains(T))
{
iSingletons++;
}
else
{
Freq.put(T,1);
}
}
Ships.put(LastShip,new ArrayList<Integer>());
if(It2.hasNext())
{
LastShip = It2.next();
}
else
{
break;
}
}
Iterator<Task> It3 = Tasks.get(TaskPos).iterator();
while(It3.hasNext())
{
It3.next().Do(Freq,Tot,iSingletons);
}
}
Iterator<Query> ItQ = Queries.iterator();
while(ItQ.hasNext())
{
ItQ.next().Answer();
}
In.close();
}

}








In   Python3 :






import bisect
from collections import defaultdict

N,Q,_ = map(int,input().split())
a = defaultdict(list)
y = list()
for _ in range( N ):
    _,y_,freq = map(int,input().split())
    a[ freq ].append( y_ )
    y.append( y_ )
    
a = { freq:sorted(y) for freq,y in a.items() if len(y) > 1 }
y = sorted( y )

res = []
for _ in range( Q ):
    y_max, y_min, T = map(int,input().split())
    lres = 0
    index_start = bisect.bisect_left(y, y_min)
    if y[ index_start ] <= y_max:
        lres = 1
        for freq in a:
            index_start = bisect.bisect_left( a[freq], y_min )
            index_stop = bisect.bisect_right( a[freq], y_max )
            lres = max( lres, index_stop - index_start )
    res.append( lres )
print(*res, sep = '\n')