"""simple docstring"""





_UpperCamelCase   :						Union[str, Any]      =    [
    [0, 16, 13, 0, 0, 0],
    [0, 0, 10, 12, 0, 0],
    [0, 4, 0, 0, 14, 0],
    [0, 0, 9, 0, 0, 20],
    [0, 0, 0, 7, 0, 4],
    [0, 0, 0, 0, 0, 0],
]





def 				a_     (      _lowerCAmelCase  : Union[str, Any]   , _lowerCAmelCase  : Optional[Any]   , _lowerCAmelCase  : Union[str, Any]   , _lowerCAmelCase  : Union[str, Any]     ):





       '''simple docstring'''

       lowercase__			:		Optional[int]       =	[False] * len(_lowerCAmelCase     )
       lowercase__			:		List[str]       =	[s]
       lowercase__			:		List[Any]       =	True

       while queue:
              lowercase__			:		int       =	queue.pop(0     )
              for ind in range(len(graph[u]     )     ):
                     if visited[ind] is False and graph[u][ind] > 0:
                            queue.append(_lowerCAmelCase     )
                            lowercase__			:		Union[str, Any]       =	True
                            lowercase__			:		Union[str, Any]       =	u

       return visited[t]





def 				a_     (      _lowerCAmelCase  : List[Any]   , _lowerCAmelCase  : List[str]   , _lowerCAmelCase  : Optional[Any]     ):





       '''simple docstring'''

       lowercase__			:		Any       =	[-1] * (len(_lowerCAmelCase     ))
       lowercase__			:		str       =	0
       lowercase__			:		int       =	[]
       lowercase__			:		Tuple       =	[i[:] for i in graph]  # Record original cut, copy.
       while bfs(_lowerCAmelCase   , _lowerCAmelCase   , _lowerCAmelCase   , _lowerCAmelCase     ):
              lowercase__			:		Union[str, Any]       =	float('Inf'     )
              lowercase__			:		Tuple       =	sink

              while s != source:
                     # Find the minimum value in select path
                     lowercase__			:		Optional[Any]       =	min(_lowerCAmelCase   , graph[parent[s]][s]     )
                     lowercase__			:		List[Any]       =	parent[s]

              max_flow += path_flow
              lowercase__			:		List[Any]       =	sink

              while v != source:
                     lowercase__			:		List[str]       =	parent[v]
                     graph[u][v] -= path_flow
                     graph[v][u] += path_flow
                     lowercase__			:		Optional[int]       =	parent[v]

       for i in range(len(_lowerCAmelCase     )     ):
              for j in range(len(graph[0]     )     ):
                     if graph[i][j] == 0 and temp[i][j] > 0:
                            res.append((i, j)     )

       return res


if __name__ == "__main__":
       print(mincut(test_graph, source=0, sink=5))








# 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

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


snake_case__					:							List[str]													=     {
    'configuration_vivit': ['VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VivitConfig'],
}
try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       snake_case__					:							Tuple													=     ['VivitImageProcessor']


try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       snake_case__					:							Any													=     [
           'VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST',
           'VivitModel',
           'VivitPreTrainedModel',
           'VivitForVideoClassification',
       ]


if TYPE_CHECKING:
       from .configuration_vivit import VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, VivitConfig

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .image_processing_vivit import VivitImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_vivit import (
                  VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  VivitForVideoClassification,
                  VivitModel,
                  VivitPreTrainedModel,
              )


else:
       import sys

       snake_case__					:							List[str]													=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





