Submission #754342

#	Submission time	Handle	Problem	Language	Result	Execution time	Memory
754342	2023-06-07T14:09:40 Z	komalrajputtrootech	Programming Contest (POI11_pro)	Python 3	0 / 100	1000 ms	13320 KB

import sys
from collections import defaultdict


def distributing_problems(contestant_problem_dict, list_of_problems, prob_solving_time, total_duration):
    num_of_solved_prob = 0
    penalty_points = 0
    problem_solving_dict = defaultdict(list)
    if total_duration > 0:
        for problem in sorted(list_of_problems, reverse=True):
            # find contestant who can solve the problem
            contestants_can_solve_problem = [participant for participant, prob_list in contestant_problem_dict.items()
                                             if problem in prob_list]
            if not contestants_can_solve_problem:
                break
            selected_contestant = contestants_can_solve_problem[0]
            # if there are more than two contestants who can solve the problem, select that contestant
            # who can solve minimum problems
            if len(contestants_can_solve_problem) > 1:
                selected_dict = dict(
                    filter(lambda item: item[0] in contestants_can_solve_problem, contestant_problem_dict.items()))
                min_val = min([len(selected_dict[ele]) for ele in selected_dict])
                for key, val in selected_dict.items():
                    if len(val) == min_val:
                        selected_contestant = key
                        break

            if selected_contestant not in problem_solving_dict:
                # as this if first problem of contestant, starting time will be 0
                start_time = 0
            else:
                # to calculate total time spent by contestant, we add problem-solving time to
                # time of last problem solved
                start_time = problem_solving_dict[selected_contestant][-1][1] + prob_solving_time

            if (start_time + prob_solving_time) > total_duration:
                break

            problem_solving_dict[selected_contestant].append((problem, start_time))
            penalty_points += start_time + prob_solving_time
            num_of_solved_prob += 1
    return num_of_solved_prob, penalty_points, problem_solving_dict


if __name__ == '__main__':
    contestant_problem_map = {}
    num_of_con, num_of_prob, solving_time, duration, num_of_pairs = sys.stdin.readline().split()
    problem_list = set()
    # create a dictionary as which contestant can solve which problem
    for pair in range(int(num_of_pairs)):
        contestant, p = sys.stdin.readline().split()
        if contestant in contestant_problem_map.keys():
            contestant_problem_map[contestant].append(p)
        else:
            contestant_problem_map.update({
                contestant: [p]
            })
        problem_list.add(p)

    num_of_problem_solved, penal_points, problems_solved_dict = distributing_problems(
        contestant_problem_map,
        list(problem_list),
        int(solving_time),
        int(duration)
    )
    print(num_of_problem_solved, penal_points)
    lst = []
    for pnt, solved_problem in problems_solved_dict.items():
        for sol in solved_problem:
            lst.append([pnt, sol[0], sol[1]])

    for i in sorted(lst, key=lambda x: (x[2], x[0])):
        print(*i)

Subtask #1
0 / 10.0

#	Verdict	Execution time	Memory	Grader output
1	Incorrect	21 ms	3404 KB	It was possible to solve 100 problems and you solved only 46.
2	Halted	0 ms	0 KB	-

Subtask #2
0 / 10.0

#	Verdict	Execution time	Memory	Grader output
1	Incorrect	17 ms	3284 KB	It was possible to solve 95 problems and you solved only 20.
2	Halted	0 ms	0 KB	-

Subtask #3
0 / 10.0

#	Verdict	Execution time	Memory	Grader output
1	Incorrect	20 ms	3412 KB	It was possible to solve 80 problems and you solved only 6.
2	Halted	0 ms	0 KB	-

Subtask #4
0 / 10.0

#	Verdict	Execution time	Memory	Grader output
1	Incorrect	48 ms	4560 KB	It was possible to solve 200 problems and you solved only 27.
2	Halted	0 ms	0 KB	-

Subtask #5
0 / 10.0

#	Verdict	Execution time	Memory	Grader output
1	Incorrect	135 ms	11068 KB	It was possible to solve 494 problems and you solved only 2.
2	Halted	0 ms	0 KB	-

Subtask #6
0 / 10.0

#	Verdict	Execution time	Memory	Grader output
1	Incorrect	119 ms	9220 KB	It was possible to solve 500 problems and you solved only 7.
2	Halted	0 ms	0 KB	-

Subtask #7
0 / 10.0

#	Verdict	Execution time	Memory	Grader output
1	Incorrect	195 ms	13320 KB	It was possible to solve 500 problems and you solved only 3.
2	Halted	0 ms	0 KB	-

Subtask #8
0 / 10.0

#	Verdict	Execution time	Memory	Grader output
1	Incorrect	53 ms	4784 KB	It was possible to solve 390 problems and you solved only 20.
2	Halted	0 ms	0 KB	-

Subtask #9
0 / 10.0

#	Verdict	Execution time	Memory	Grader output
1	Execution timed out	1057 ms	9900 KB	Time limit exceeded
2	Halted	0 ms	0 KB	-

Subtask #10
0 / 10.0

#	Verdict	Execution time	Memory	Grader output
1	Incorrect	76 ms	5452 KB	It was possible to solve 452 problems and you solved only 28.
2	Halted	0 ms	0 KB	-

Submission #754342

Compilation message