Submission #754371

# Submission time Handle Problem Language Result Execution time Memory
754371 2023-06-07T15:13:33 Z komalrajputtrootech Programming Contest (POI11_pro) Python 3
0 / 100
809 ms 21632 KB
import sys
from collections import defaultdict


def distributing_problems(contestant_problem_dict, problem_contestant_map, list_of_problems, prob_solving_time, total_duration):
    num_of_solved_prob = 0
    penalty_points = 0
    problem_solving_dict = defaultdict(list)
    for problem in sorted(list_of_problems, reverse=True):
        # find contestant who can solve the problem
        contestants_can_solve_problem = problem_contestant_map[problem]
        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 = {}
    problem_contestant_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]
            })

        if p in problem_contestant_map.keys():
            problem_contestant_map[p].append(contestant)
        else:
            problem_contestant_map.update({
                p: [contestant]
            })
        problem_list.add(p)

    num_of_problem_solved, penal_points, problems_solved_dict = distributing_problems(
        contestant_problem_map,
        problem_contestant_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)
# Verdict Execution time Memory Grader output
1 Incorrect 19 ms 3412 KB It was possible to solve 100 problems and you solved only 46.
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 18 ms 3344 KB It was possible to solve 95 problems and you solved only 20.
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 22 ms 3620 KB It was possible to solve 80 problems and you solved only 6.
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 73 ms 5664 KB It was possible to solve 200 problems and you solved only 27.
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 196 ms 17792 KB It was possible to solve 494 problems and you solved only 2.
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 158 ms 14332 KB It was possible to solve 500 problems and you solved only 7.
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 221 ms 21632 KB It was possible to solve 500 problems and you solved only 3.
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 55 ms 6020 KB It was possible to solve 390 problems and you solved only 20.
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 809 ms 15400 KB It was possible to get penalty of 500 points and you received 19324.
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 68 ms 7244 KB It was possible to solve 452 problems and you solved only 28.
2 Halted 0 ms 0 KB -