Problem:


Score : 400 points

Problem Statement

Joisino is planning to record N TV programs with recorders.

The TV can receive C channels numbered 1 through C.

The i-th program that she wants to record will be broadcast from time s_i to time t_i (including time s_i but not t_i) on Channel c_i.

Here, there will never be more than one program that are broadcast on the same channel at the same time.

When the recorder is recording a channel from time S to time T (including time S but not T), it cannot record other channels from time S-0.5 to time T (including time S-0.5 but not T).

Find the minimum number of recorders required to record the channels so that all the N programs are completely recorded.

Constraints

1≤N≤10^5

1≤C≤30

1≤s_i<t_i≤10^5

1≤c_i≤C

If c_i=c_j and i≠j, either t_i≤s_j or s_i≥t_j.

All input values are integers.

Input

Input is given from Standard Input in the following format:

N C
s_1 t_1 c_1
:
s_N t_N c_N

Output

When the minimum required number of recorders is x, print the value of x.

Sample Input 1

3 2
1 7 2
7 8 1
8 12 1

Sample Output 1

2

Two recorders can record all the programs, for example, as follows:

With the first recorder, record Channel 2 from time 1 to time 7. The first program will be recorded. Note that this recorder will be unable to record other channels from time 0.5 to time 7.

With the second recorder, record Channel 1 from time 7 to time 12. The second and third programs will be recorded. Note that this recorder will be unable to record other channels from time 6.5 to time 12.

Sample Input 2

3 4
1 3 2
3 4 4
1 4 3

Sample Output 2

3

There may be a channel where there is no program to record.

Sample Input 3

9 4
56 60 4
33 37 2
89 90 3
32 43 1
67 68 3
49 51 3
31 32 3
70 71 1
11 12 3

Sample Output 3

2



Sample input:
3 2
1 7 2
7 8 1
8 12 1


Sample output:
2

Submission status: Wrong Answer

Solution code:
n,C=[int(i) for i in input().split()]
stc=[[int(i) for i in input().split()] for _ in range(n)]
stc.sort(key=lambda x:x[1])
stc.sort(key=lambda x:x[2])
time=[0]*(2*(10**5+1))
end=[[0]*(10**5+1) for _ in range(C)]

for s,t,c in stc:
    end[c-1][t]+=1

for s,t,c in stc:
    if end[c-1][s]==0:
        time[2*s-1]+=1
    time[2*t]-=1
for i in range(1,2*10**5+2):
    time[i]=time[i-1]+time[i]
print(max(time))

Submission status: Wrong Answer

Solution code:
n,c=[int(i) for i in input().split()]
stc=[[int(i) for i in input().split()] for _ in range(n)]
time=[0]*(2*(10**5+1))
for s,t,c in stc:
    time[2*s-1]+=1
    time[2*t]-=1
for i in range(1,2*10**5+2):
    time[i]=time[i-1]+time[i]
print(max(time))

Submission status: Wrong Answer

Solution code:
n,c=[int(i) for i in input().split()]
stc=[[int(i) for i in input().split()] for _ in range(n)]
time=[0]*(2*(10**5+1))
for s,t,c in stc:
    time[2*s-1]+=1
    time[2*t]-=1
for i in range(1,10**5+1):
    time[i]=time[i-1]+time[i]
print(max(time))

Submission status: Wrong Answer

Solution code:
n,c=[int(i) for i in input().split()]
stc=[[int(i) for i in input().split()] for _ in range(n)]
time=[0]*(10**5+1)
for s,t,c in stc:
    time[s-1]+=1
    time[t]-=1
for i in range(1,10**5+1):
    time[i]=time[i-1]+time[i]
print(max(time))

Submission status: Wrong Answer

Solution code:
N, C = map(int, input().split())
channels = [[] for _ in range(C)]
for _ in range(N):
    a, b, c = map(int, input().split())
    channels[c-1].append((a, b))
for c in range(C):
    channels[c].sort()
recorders = [0]*(10**5+2)
for c in channels:
    if c:
        recorders[c[0][0]] += 1; recorders[c[0][1] + 1] -= 1;
        for i in range(1, len(c)):
            if c[i][0] == c[i-1][1]:
                recorders[c[i][0] + 1] += 1; recorders[c[i][1] + 1] -= 1;
            else:
                recorders[c[i][0]] += 1; recorders[c[i][1]] -= 1;
for i in range(1, len(recorders)):
    recorders[i] += recorders[i-1]
print(max(recorders))

Submission status: Wrong Answer

Solution code:
N, C = map(int, input().split())
channels = [[] for _ in range(C)]
for _ in range(N):
    a, b, c = map(int, input().split())
    channels[c-1].append((a, b))
for c in range(C):
    channels[c].sort()
recorders = [0]*(10**5+2)
for c in channels:
    if c:
        recorders[c[0][0]] += 1; recorders[c[0][1]] -= 1;
        for i in range(1, len(c)):
            if c[i][0] == c[i-1][1]:
                recorders[c[i][0] + 1] += 1; recorders[c[i][1] + 1] -= 1;
            else:
                recorders[c[i][0]] += 1; recorders[c[i][1]] -= 1;
for i in range(1, len(recorders)):
    recorders[i] += recorders[i-1]
print(max(recorders))

Submission status: Wrong Answer

Solution code:
N, C = map(int, input().split())
programs = [tuple(map(int, input().split())) for _ in range(N)]
programs = sorted(programs, key=lambda x: x[1])
ans = 1
for i in range(1, N):
    s1, t1, c1 = programs[i-1]
    s2, t2, c2 = programs[i]
    if c1 != c2: s2 -= 0.5
    if s2 < t1: ans += 1
print(ans)

Submission status: Wrong Answer

Solution code:
n,C = map(int,input().split())
STC = [list(map(int,input().split())) for _ in range(n)]

import numpy as np

imosc = np.zeros((C+1,10**5+3),dtype = 'int16')
imos = np.zeros((1,10**5+3),dtype = 'int16')

for s,t,c in STC:
    if imosc[c][s+1] == -1:
        imosc[c][s+1] = 0
        imosc[c][t+1] = -1
    elif imosc[c][t] == 1:
        imosc[c][s] = 1
        imosc[c][t] = 0
    else:
        imosc[c][s] = 1
        imosc[c][t+1] = -1
        

for i in range(1,C+1):
    imos = imosc[i] + imos
for i in range(1,10**5+2):
    imos[0][i] += imos[0][i-1]
print(np.max(imos[0]))

Submission status: Wrong Answer

Solution code:
n,C = map(int,input().split())

import numpy as np

imosc = np.zeros((C+1,10**5+3),dtype = 'int16')
imos = np.zeros((1,10**5+3),dtype = 'int16')

for i in range(n):
    s,t,c = map(int,input().split())
    if imosc[c][s+1] == -1:
        imosc[c][s+1] = 0
        imosc[c][t+1] = -1
    elif imosc[c][t] == 1:
        imosc[c][s] = 1
        imosc[c][t] = 0
    else:
        imosc[c][s] = 1
        imosc[c][t+1] = -1
        

for i in range(1,C+1):
    imos = imosc[i] + imos
for i in range(1,10**5+2):
    imos[0][i] += imos[0][i-1]
print(np.max(imos[0]))

Submission status: Wrong Answer

Solution code:
n,C = map(int,input().split())
STC = [list(map(int,input().split())) for _ in range(n)]

import numpy as np

imosc = np.zeros((C+1,10**5+3),dtype = 'int16')
imos = np.zeros((1,10**5+3),dtype = 'int16')

for s,t,c in STC:
    if imosc[c][s+1] == -1:
        imosc[c][s+1] = 0
        imosc[c][t+1] = -1
    elif imosc[c][t] == 1:
        imosc[c][s] = 1
        imosc[c][t] = 0
    elif imosc[c][t+1] == 1:
        imosc[c][s] = 1
        imosc[c][t+1] = 0
    else:
        imosc[c][s] = 1
        imosc[c][t+1] = -1
        

for i in range(1,C+1):
    imos = imosc[i] + imos
for i in range(1,10**5+2):
    imos[0][i] += imos[0][i-1]
print(np.max(imos[0]))

Submission status: Wrong Answer

Solution code:
n,C = map(int,input().split())
STC = [list(map(int,input().split())) for _ in range(n)]

import numpy as np

imosc = np.zeros((C+1,10**5+3),dtype = 'int16')
imos = np.zeros((1,10**5+3),dtype = 'int16')

for s,t,c in STC:
    if imosc[c][s+1] == -1:
        imosc[c][s+1] = 0
        imosc[c][t+1] = -1
    elif imosc[c][t] == 1:
        imosc[c][s] = 1
        imosc[c][t-1] = 0
    else:
        imosc[c][s] = 1
        imosc[c][t] = -1
        

for i in range(1,C+1):
    imos = imosc[i] + imos
for i in range(1,10**5+2):
    imos[0][i] += imos[0][i-1]
print(np.max(imos[0]))

Submission status: Wrong Answer

Solution code:
n,C = map(int,input().split())
STC = [list(map(int,input().split())) for _ in range(n)]

import numpy as np

imosc = np.zeros((C+1,10**5+3),dtype = 'int16')
imos = np.zeros((1,10**5+3),dtype = 'int16')

for s,t,c in STC:
    if imosc[c][s+1] == -1:
        imosc[c][s+1] = 0
        imosc[c][t+1] = -1
    elif imosc[c][t-1] == 1:
        imosc[c][s] = 1
        imosc[c][t-1] = 0
    else:
        imosc[c][s] = 1
        imosc[c][t+1] = -1
        

for i in range(1,C+1):
    imos = imosc[i] + imos
for i in range(1,10**5+2):
    imos[0][i] += imos[0][i-1]
print(np.max(imos[0]))

Submission status: Wrong Answer

Solution code:
n,C = map(int,input().split())
STC = [list(map(int,input().split())) for _ in range(n)]

import numpy as np

imosc = np.zeros((C+1,10**5+3),dtype = 'int16')
imos = np.zeros((1,10**5+3),dtype = 'int16')

for s,t,c in STC:
    if imosc[c][s] == -1:
        imosc[c][s] = 0
        imosc[c][t+1] = -1
    elif imosc[c][t-1] == 1:
        imosc[c][s] = 1
        imosc[c][t-1] = 0
    else:
        imosc[c][s] = 1
        imosc[c][t+1] = -1
        

for i in range(1,C+1):
    imos = imosc[i] + imos
for i in range(1,10**5+2):
    imos[0][i] += imos[0][i-1]
print(np.max(imos[0]))

Submission status: Wrong Answer

Solution code:
n,c = map(int,input().split())
rec = []
cnt = 1
before = 0
M = 0
for N in range(n):
    s,t,c = map(int,input().split())
    rec.append([s,t,c])
rec.sort()
for N in range(1,n):
    recn = rec[N]
    recb = rec[before]
    if recn[2] == recb[2]:
        time  = 0
    else:time = 0.5
    if recn[0] - time <= recb[1]:
        cnt += 1
    else:
        M = max(cnt,M)
        cnt = 1
        before = N
M = max(cnt,M)
print(M)

Submission status: Wrong Answer

Solution code:
n,c = map(int,input().split())
STC = [list(map(int,input().split())) for _ in range(n)]

imos = [0]*(10**5+5)

for s,t,c in STC:
    imos[s] += 1
    imos[t+1] -= 1 
for i in range(1,10**5+5):
    imos[i] += imos[i-1]
print(max(imos))

Submission status: Wrong Answer

Solution code:
n,c = map(int,input().split())
rec = []
cnt = 1
before = 0
M = 0
for N in range(n):
    s,t,c = map(int,input().split())
    rec.append([s,t,c])
rec.sort()
for N in range(1,n):
    recn = rec[N]
    recb = rec[before]
    if recn[2] == recb[2]:
        time  = 0
    else:time = 0.5
    if recn[0] - time < recb[1]:
        cnt += 1
    else:
        M = max(cnt,M)
        cnt = 1
        before = N
M = max(cnt,M)
print(M)

Submission status: Wrong Answer

Solution code:
n,c = map(int,input().split())
STC = [list(map(int,input().split())) for _ in range(n)]

imos = [0]*(10**5+2)

for s,t,c in STC:
    imos[s] += 1
    imos[t+1] -= 1 
for i in range(1,10**5+2):
    imos[i] += imos[i-1]
print(max(imos))

Submission status: Wrong Answer

Solution code:
import sys
from itertools import accumulate

# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
#  0.5sec as one unit
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]

for s, t, c in STC:
    c -= 1
    tbl[c][2*s-1] = 1
    tbl[c][2*t] = -1

tbl2 = [list(accumulate(a)) for a in tbl]
# for i in range(200002):
#      for j in range(C):
#          if tbl2[j][i]>1:
#           	tbl2[j][i]=1

ans = max([sum(x) for x in zip(*tbl2)])
print(ans)

# tmp = [sum(x) for x in zip(*tbl2)]

# res = 0
# for i in range(200002):
#     cc = 0
#     for j in range(C):
#         if tbl2[j][i]:
#             cc += 1
#     res = max(res, cc)
# print(res)

Submission status: Wrong Answer

Solution code:
import sys
from itertools import accumulate

# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
#  0.5sec as one unit
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]

for s, t, c in STC:
    c -= 1
    # if we can record the programms continuously (ver1)
    if tbl[c][2*s] != 0:
        tbl[c][2*s] = 0
        tbl[c][2*t] = 1
    # if we can record the programms continuously (ver2)
    elif tbl[c][2*t-1] != 0:
        tbl[c][2*t-1] = 0
        tbl[c][2*s-1] = 1
    # else:
    else:
        tbl[c][2*s-1] = 1
        tbl[c][2*t] = -1

tbl2 = [list(accumulate(a)) for a in tbl]

ans = max([sum(x) for x in zip(*tbl2)])
print(ans)

# tmp = [sum(x) for x in zip(*tbl2)]

# res = 0
# for i in range(200002):
#     cc = 0
#     for j in range(C):
#         if tbl2[j][i]:
#             cc += 1
#     res = max(res, cc)
# print(res)

Submission status: Wrong Answer

Solution code:
import sys
from itertools import accumulate

# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
#  0.5sec as one unit
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]

for s, t, c in STC:
    c -= 1
    # if we can record the programms continuously (ver1)
    if tbl[c][2*s] == -1:
        tbl[c][2*s] = 0
        tbl[c][2*t] = -1
    # if we can record the programms continuously (ver2)
    elif tbl[c][2*t-1] == 1:
        tbl[c][2*t-1] = 0
        tbl[c][2*s-1] = 1
    # else:
    else:
        tbl[c][2*s-1] = 1
        tbl[c][2*t] = -1

tbl2 = [list(accumulate(a)) for a in tbl]
# for i in range(200002):
#      for j in range(C):
#          if tbl2[j][i]>1:
#           	tbl2[j][i]=1

ans = max([sum(x) for x in zip(*tbl2)])
print(ans)

# tmp = [sum(x) for x in zip(*tbl2)]

# res = 0
# for i in range(200002):
#     cc = 0
#     for j in range(C):
#         if tbl2[j][i]:
#             cc += 1
#     res = max(res, cc)
# print(res)

Submission status: Wrong Answer

Solution code:
import sys
from itertools import accumulate

# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
#  0.5sec as one unit
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]

for s, t, c in STC:
    c -= 1
    # if we can record the programms continuously (ver1)
    if tbl[c][2*s] != 0:
        tbl[c][2*s] += 1
        tbl[c][2*t] -= 1
    # if we can record the programms continuously (ver2)
    elif tbl[c][2*t-1] != 0:
        tbl[c][2*t-1] -= 1
        tbl[c][2*s-1] += 1
    elif tbl[c][2*t+1] != 0:
        tbl[c][2*t+1] -= 1
        tbl[c][2*s-1] += 1
    # else:
    else:
        tbl[c][2*s-1] = 1
        tbl[c][2*t] = -1

tbl2 = [list(accumulate(a)) for a in tbl]

ans = max([sum(x) for x in zip(*tbl2)])
print(ans)

# tmp = [sum(x) for x in zip(*tbl2)]

# res = 0
# for i in range(200002):
#     cc = 0
#     for j in range(C):
#         if tbl2[j][i]:
#             cc += 1
#     res = max(res, cc)
# print(res)

Submission status: Wrong Answer

Solution code:
import sys
from itertools import accumulate

# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
#  0.5sec as one unit
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]

for s, t, c in STC:
    c -= 1
    # if we can record the programms continuously (ver1)
    if tbl[c][2*s] != 0:
        tbl[c][2*s] += 1
        tbl[c][2*t] -= 1
    # if we can record the programms continuously (ver2)
    elif tbl[c][2*t+1] != 0:
        tbl[c][2*t+1] -= 1
        tbl[c][2*s-1] += 1
    # else:
    else:
        tbl[c][2*s-1] = 1
        tbl[c][2*t] = -1

tbl2 = [list(accumulate(a)) for a in tbl]

ans = max([sum(x) for x in zip(*tbl2)])
print(ans)

# tmp = [sum(x) for x in zip(*tbl2)]

# res = 0
# for i in range(200002):
#     cc = 0
#     for j in range(C):
#         if tbl2[j][i]:
#             cc += 1
#     res = max(res, cc)
# print(res)

Submission status: Wrong Answer

Solution code:
import sys
from itertools import accumulate
 
# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
#  0.5sec as one unit
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]
 
for s, t, c in STC:
    c -= 1
    # if we can record the programms continuously (ver1)
    if tbl[c][2*s] != 0:
        tbl[c][2*s] += 1
        tbl[c][2*t] -= 1
    # if we can record the programms continuously (ver2)
    elif tbl[c][2*t-1] != 0:
        tbl[c][2*t-1] -= 1
        tbl[c][2*s-1] += 1
    # else:
    else:
        tbl[c][2*s-1] = 1
        tbl[c][2*t] = -1
 
tbl2 = [list(accumulate(a)) for a in tbl]
 
# ans = max([sum(x) for x in zip(*tbl2)])
# print(ans)
 
res = 0
for i in range(200002):
    cc = 0
    for j in range(C):
        if tbl2[j][i]:
            cc += tbl2[j][i]
    res = max(res, cc)
print(res)

Submission status: Wrong Answer

Solution code:
import sys
from itertools import accumulate

# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
#  0.5sec as one unit
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]

for s, t, c in STC:
    c -= 1
    # if we can record the programms continuously (ver1)
    if tbl[c][2*s] != 0:
        tbl[c][2*s] += 1
        tbl[c][2*s] -= 1
    # if we can record the programms continuously (ver2)
    elif tbl[c][2*t-1] != 0:
        tbl[c][2*t-1] -= 1
        tbl[c][2*t-1] += 1
    # else:
    else:
        tbl[c][2*s-1] = 1
        tbl[c][2*t] = -1

tbl2 = [list(accumulate(a)) for a in tbl]

ans = max([sum(x) for x in zip(*tbl2)])
print(ans)

# tmp = [sum(x) for x in zip(*tbl2)]

# res = 0
# for i in range(200002):
#     cc = 0
#     for j in range(C):
#         if tbl2[j][i]:
#             cc += 1
#     res = max(res, cc)
# print(res)

Submission status: Wrong Answer

Solution code:
import sys
from itertools import accumulate

# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
#  0.5sec as one unit
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]

for s, t, c in STC:
    c -= 1
    # if we can record the programms continuously (ver1)
    if tbl[c][2*s] != 0:
        tbl[c][2*s] += 1
        tbl[c][2*s] -= 1
    # if we can record the programms continuously (ver2)
    elif tbl[c][2*t-1] != 0:
        tbl[c][2*t-1] -= 1
        tbl[c][2*s-1] += 1
    # else:
    else:
        tbl[c][2*s-1] = 1
        tbl[c][2*t] = -1

tbl2 = [list(accumulate(a)) for a in tbl]

ans = max([sum(x) for x in zip(*tbl2)])
print(ans)

# tmp = [sum(x) for x in zip(*tbl2)]

# res = 0
# for i in range(200002):
#     cc = 0
#     for j in range(C):
#         if tbl2[j][i]:
#             cc += 1
#     res = max(res, cc)
# print(res)

Submission status: Wrong Answer

Solution code:
import sys
from itertools import accumulate

# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
#  0.5sec as one unit
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]

for s, t, c in STC:
    c -= 1
    # if we can record the programms continuously (ver1)
    if tbl[c][2*s] != 0:
        tbl[c][2*s] += 1
        tbl[c][2*t] -= 1
    # if we can record the programms continuously (ver2)
    elif tbl[c][2*t-1] != 0:
        tbl[c][2*t-1] -= 1
        tbl[c][2*s-1] += 1
    # else:
    else:
        tbl[c][2*s-1] = 1
        tbl[c][2*t] = -1

tbl2 = [list(accumulate(a)) for a in tbl]

# ans = max([sum(x) for x in zip(*tbl2)])
# print(ans)

res = 0
for i in range(200002):
    cc = 0
    for j in range(C):
        cc += 1
    res = max(res, cc)
print(res)

Submission status: Wrong Answer

Solution code:
import sys
from itertools import accumulate
 
# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
#  0.5sec as one unit
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]
 
for s, t, c in STC:
    c -= 1
    # if we can record the programms continuously (ver1)
    if tbl[c][2*s] != 0:
        tbl[c][2*s] += 1
        tbl[c][2*t] -= 1
    # if we can record the programms continuously (ver2)
    elif tbl[c][2*t-1] != 0:
        tbl[c][2*t-1] -= 1
        tbl[c][2*s-1] += 1
    # else:
    else:
        tbl[c][2*s-1] = 1
        tbl[c][2*t] = -1
 
tbl2 = [list(accumulate(a)) for a in tbl]
 
# ans = max([sum(x) for x in zip(*tbl2)])
# print(ans)
 
res = 0
for i in range(200002):
    cc = 0
    for j in range(C):
        if tbl2[j][i]:
            cc += tbl2[j][i]
    res = max(res, cc)
print(res)

Submission status: Wrong Answer

Solution code:
import sys
from itertools import accumulate
 
# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
#  0.5sec as one unit
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]
 
for s, t, c in STC:
    c -= 1
    # if we can record the programms continuously (ver1)
    if tbl[c][2*s] != 0:
        tbl[c][2*s] += 1
        tbl[c][2*t] -= 1
    # if we can record the programms continuously (ver2)
    elif tbl[c][2*t-1] != 0:
        tbl[c][2*t-1] -= 1
        tbl[c][2*s-1] += 1
    # else:
    else:
        tbl[c][2*s-1] = 1
        tbl[c][2*t] = -1
 
tbl2 = [list(accumulate(a)) for a in tbl]
 
# ans = max([sum(x) for x in zip(*tbl2)])
# print(ans)
 
res = 0
for i in range(200002):
    cc = 0
    for j in range(C):
        if tbl2[j][i]:
            cc += tbl[j][i]
    res = max(res, cc)
print(res)

Submission status: Wrong Answer

Solution code:
import sys
from itertools import accumulate

# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
#  0.5sec as one unit
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]

for s, t, c in STC:
    c -= 1
    # if we can record the programms continuously (ver1)
    if tbl[c][2*s] != 0:
        tbl[c][2*s] += 1
        tbl[c][2*t] -= 1
    # if we can record the programms continuously (ver2)
    elif tbl[c][2*t-1] != 0:
        tbl[c][2*t-1] -= 1
        tbl[c][2*s-1] += 1
    # else:
    else:
        tbl[c][2*s-1] = 1
        tbl[c][2*t] = -1

tbl2 = [list(accumulate(a)) for a in tbl]

ans = max([sum(x) for x in zip(*tbl2)])
print(ans)

# tmp = [sum(x) for x in zip(*tbl2)]

# res = 0
# for i in range(200002):
#     cc = 0
#     for j in range(C):
#         if tbl2[j][i]:
#             cc += 1
#     res = max(res, cc)
# print(res)

Submission status: Wrong Answer

Solution code:
N,C = map(int,input().split())
cum = [0]*(10**5+1)
for _ in range(N):
    s,t,c = map(int,input().split())
    cum[s-1] += 1
    cum[t] -= 1
for i in range(10**5):
    cum[i+1] += cum[i]
print(max(cum))

Submission status: Wrong Answer

Solution code:
# using main() makes code faster from the point of view of "access to variables in global name-space"
# def main():

# for i, a in enumerate(iterable)
# q, mod = divmod(a, b)
# divmod(x, y) returns the tuple (x//y, x%y)
# manage median(s) using two heapq https://atcoder.jp/contests/abc127/tasks/abc127_f
import sys
sys.setrecursionlimit(10**7)
from itertools import accumulate, combinations, permutations # https://docs.python.org/ja/3/library/itertools.html
from math import factorial
def combinations_count(n, r):
    # faster than the following code
    # def combinations_count(n, r):
    #     return factorial(n) // (factorial(n - r) * factorial(r))
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n
    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]
    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot
    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])
    return result
def combination_with_repetition_count(n, r):
    return combinations_count(n + r - 1, r)
from collections import deque, Counter # https://docs.python.org/ja/3/library/collections.html#collections.deque
from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest # https://docs.python.org/ja/3/library/heapq.html
from copy import deepcopy, copy # https://docs.python.org/ja/3/library/copy.html
from operator import itemgetter 
# ex1: List.sort(key=itemgetter(1))
# ex2: sorted(tuples, key=itemgetter(1,2))
from functools import reduce
from fractions import gcd # Deprecated since version 3.5: Use math.gcd() instead.
def gcds(numbers):
    return reduce(gcd, numbers)
def lcm(x, y):
    return (x * y) // gcd(x, y)
def lcms(numbers):
    return reduce(lcm, numbers, 1)

# first create factorial_list
# fac_list = mod_factorial_list(n)
INF = 10 ** 18
MOD = 10 ** 6 + 3
modpow = lambda a, n, p = MOD: pow(a, n, p) # Recursive function in python is slow!
def modinv(a, p = MOD):
    # evaluate reciprocal using Fermat's little theorem:
    # a**(p-1) is identical to 1 (mod p) when a and p is coprime
    return modpow(a, p-2, p)
def modinv_list(n, p = MOD):
    if n <= 1:
        return [0,1][:n+1]
    else:
        inv_t = [0,1]
        for i in range(2, n+1):
            inv_t += [inv_t[p % i] * (p - int(p / i)) % p]
        return inv_t
def modfactorial_list(n, p = MOD):
    if n == 0:
        return [1]
    else:
        l = [0] * (n+1)
        tmp = 1
        for i in range(1, n+1):
            tmp = tmp * i % p
            l[i] = tmp
        return l
def modcomb(n, k, fac_list = [], p = MOD):
    # fac_list = modfactorial_list(100)
    # print(modcomb(100, 5, modfactorial_list(100)))
    from math import factorial
    if n < 0 or k < 0 or n < k: return 0
    if n == 0 or k == 0: return 1
    if len(fac_list) <= n:
        a = factorial(n) % p
        b = factorial(k) % p
        c = factorial(n-k) % p
    else:
        a = fac_list[n]
        b = fac_list[k]
        c = fac_list[n-k]
    return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p
def modadd(a, b, p = MOD):
    return (a + b) % MOD
def modsub(a, b, p = MOD):
    return (a - b) % p
def modmul(a, b, p = MOD):
    return ((a % p) * (b % p)) % p
def moddiv(a, b, p = MOD):
    return modmul(a, modpow(b, p-2, p))


# initialize variables and set inputs
#initialize variables
    # to initialize list, use [0] * n
    # to initialize two dimentional array, use [[0] * N for _ in range(N)]
# set inputs
    # open(0).read() is a convenient method:
    # ex) n, m, *x = map(int, open(0).read().split())
    #     min(x[::2]) - max(x[1::2])
    # ex2) *x, = map(int, open(0).read().split())
    #     don't forget to add comma after *x if only one variable is used
# calculate and output
    # output pattern
    # ex1) print(*l) => when l = [2, 5, 6], printed 2 5 6

# set test data
# sys.stdin = open('sample.txt') # for test

# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]

# watch out: join tv programmes which are continuously broadcast in one channel
for s, t, c in STC:
    c -= 1
    if tbl[c][2*s] != 0:
        tbl[c][2*s] += 1
        tbl[c][2*t] -= 1
    elif tbl[c][2*t-1] != 0:
        tbl[c][2*t-1] -= 1
        tbl[c][2*s-1] += 1
    else:
        tbl[c][2*s-1] = 1
        tbl[c][2*t] = -1
# for s, t, c in STC:
#     c -= 1
#     if tbl[c][s] == -1:
#         tbl[c][s] = 0
#         tbl[c][t] = -1
#     elif tbl[c][t-1] == 1:
#         tbl[c][s-1] = 1
#         tbl[c][t-1] = 0
#     else:
#         tbl[c][s-1] = 1
#         tbl[c][t] = -1

tbl2 = [list(accumulate(a)) for a in tbl]
tmp = [sum(x) for x in zip(*tbl2)]
print(max(tmp))
# ans = max([sum(x) for x in zip(*tbl2)])
# print(ans)

# tmp = [sum(x) for x in zip(*tbl2)]

# res = 0
# for i in range(200002):
#     cc = 0
#     for j in range(C):
#         if tbl2[j][i]:
#             cc += 1
#     res = max(res, cc)
 
# print(res)

# if __name__ == '__main__':
#     main()

Submission status: Wrong Answer

Solution code:
from itertools import accumulate
import sys

# functions used
r = lambda: sys.stdin.readline().strip() #single: int(r()), line: map(int, r().split())
R = lambda: list(map(int, r().split())) # line: R(), lines: [R() for _ in range(n)]
Rmap = lambda: map(int, r().split())
# set inputs
N, C = R()
STC = [R() for _ in range(N)]
tbl = [[0]*(2*(10**5)+5) for _ in range(C)]

# watch out: join tv programmes which are continuously broadcast in one channel
for s, t, c in STC:
    c -= 1
    if tbl[c][2*s] != 0:
        tbl[c][2*s] += 1
        tbl[c][2*t] -= 1
    elif tbl[c][2*t-1] != 0:
        tbl[c][2*t-1] -= 1
        tbl[c][2*s-1] += 1
    else:
        tbl[c][2*s-1] = 1
        tbl[c][2*t] = -1

tbl2 = [list(accumulate(a)) for a in tbl]
ans = max([sum(x) for x in zip(*tbl2)])
print(ans)