





"""simple docstring"""






from collections import defaultdict



class 	lowerCAmelCase					:






       def __init__(   self    ,  a__    ,  a__     ):
              _UpperCAmelCase     =     total  # total no of tasks (N)

              # DP table will have a dimension of (2^M)*N
              # initially all values are set to -1
              _UpperCAmelCase     =     [
                  [-1 for i in range(total + 1     )] for j in range(2 ** len(a__     )     )
              ]

              _UpperCAmelCase     =     defaultdict(a__     )  # stores the list of persons for each task

              # final_mask is used to check if all persons are included by setting all bits
              # to 1
              _UpperCAmelCase     =     (1 << len(a__     )) - 1






       def 							__A (   self    ,  a__    ,  a__     ):
              # if mask == self.finalmask all persons are distributed tasks, return 1
              if mask == self.final_mask:
                     return 1

              # if not everyone gets the task and no more tasks are available, return 0
              if task_no > self.total_tasks:
                     return 0

              # if case already considered
              if self.dp[mask][task_no] != -1:
                     return self.dp[mask][task_no]

              # Number of ways when we don't this task in the arrangement
              _UpperCAmelCase     =     self.count_ways_until(a__    ,  task_no + 1     )

              # now assign the tasks one by one to all possible persons and recursively
              # assign for the remaining tasks.
              if task_no in self.task:
                     for p in self.task[task_no]:
                            # if p is already given a task
                            if mask & (1 << p):
                                   continue

                            # assign this task to p and change the mask value. And recursively
                            # assign tasks with the new mask value.
                            total_ways_util += self.count_ways_until(mask | (1 << p)    ,  task_no + 1     )

        # save the value.
              _UpperCAmelCase     =     total_ways_util

              return self.dp[mask][task_no]






       def 							__A (   self    ,  a__     ):
              # Store the list of persons for each task
              for i in range(len(a__     )     ):
                     for j in task_performed[i]:
                            self.task[j].append(a__     )

        # call the function to fill the DP table, final answer is stored in dp[0][1]
              return self.count_ways_until(0    ,  1     )


if __name__ == "__main__":
    lowerCAmelCase_			=							5  # total no of tasks (the value of N)

    # the list of tasks that can be done by M persons.
    lowerCAmelCase_			=							[[1, 3, 4], [1, 2, 5], [3, 4]]
    print(
        AssignmentUsingBitmask(task_performed, total_tasks).count_no_of_ways(
            task_performed
        )
    )













"""simple docstring"""






# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase_			=							{'''configuration_timm_backbone''': ['''TimmBackboneConfig''']}


try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCAmelCase_			=							['''TimmBackbone''']


if TYPE_CHECKING:
    from .configuration_timm_backbone import TimmBackboneConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_timm_backbone import TimmBackbone

else:
    import sys

    lowerCAmelCase_			=							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






