Python Solution with Explanation
We can solve the problem in 2 steps:\n1. Select those who maybe be good by a scanning: for those who I say is good, none of them says I\'m bad.\n2. Evaluate if 
We can solve the problem in 2 steps:\n1. Select those who maybe be good by a scanning: for those who I say is good, none of them says I\'m bad.\n2. Evaluate if the set of "may be good" is valid.\n\t2.1. If yes, return the size of this set.\n\t2.2. If no, we remove any of the member from the set and repeat the evaluation.\n\nHowever, some sets of "may be good" may appear many times, so we need to mask this set and avoid evluating it again.\n\nBelow is an implementation in Python3:\n```python\nclass Solution:\n    def is_valid(self, good_set: Set[int], statements: List[List[int]]) -> bool:\n        for idx in good_set:\n            for i in range(len(statements[idx])):\n                # decribed as bad but in the good set\n                if statements[idx][i] == 0 and i in good_set:\n                    return False\n                # decribed as good but in the bad set\n                if statements[idx][i] == 1 and i not in good_set:\n                    return False\n                \n        return True\n    \n    def set_to_mask(self, good_set: Set[int], n: int) -> str:\n        ret = ["0"] * n\n        for i in good_set:\n            ret[i] = "1"\n            \n        return "".join(ret)\n    \n    def maximumGood(self, statements: List[List[int]]) -> int:\n        """\n        every person can be:\n        1. good.\n        2. bad but telling the truth.\n        3. bad but lying.\n        \n        minimize certainly bad to maximize probably good.\n        1. the network contains good people are always valid.\n        2. Bruteforce, try to remove any one see if it makes the network valid.\n        \n        As a good person:\n        1. When I say someone is bad, his statement doesn\'t affect me.\n        2. When I say someone is good, he must also say I\'m good or no comment, otherwise contradiction.\n        """\n        n = len(statements)\n        \n        # select those who can be good\n        can_be_good_set = set()\n        for i, statement in enumerate(statements):\n            can_be_good = True\n            for j, comment in enumerate(statement):\n                # i says j is good but j says i is bad\n                if comment == 1 and statements[j][i] == 0:\n                    can_be_good = False\n                if not can_be_good:\n                    False\n            if can_be_good:\n                can_be_good_set.add(i)\n                    \n        # if the combination of those who can be good is not valid\n        # we try remove one of them\n        Q = [can_be_good_set]\n        seen = {self.set_to_mask(can_be_good_set, n)}\n        while len(Q) > 0: \n            can_be_good_set = Q.pop(0)\n            if self.is_valid(can_be_good_set, statements):\n                return len(can_be_good_set)\n            else:\n                for can_be_good in can_be_good_set:\n                    _can_be_good_set = can_be_good_set - {can_be_good}\n                    mask = self.set_to_mask(_can_be_good_set, n)\n                    if mask not in seen:\n                        Q.append(_can_be_good_set)\n                        seen.add(mask)\n\n        return 0\n```
[]