def check_uva_userid1(what):
chars = list(what.lower())
# check first character (must be a letter)
if len(chars) == 0: return False
if not chars[0].isalpha(): return False
chars.pop(0)
# check second character (must be a letter)
if len(chars) == 0: return False
if not chars[0].isalpha(): return False
chars.pop(0)
# return true if of the form ll
if len(chars) == 0: return True
# check optional 3rd letter
if chars[0].isalpha():
chars.pop(0)
# return true if of the form lll
if len(chars) == 0: return True
# check digit
if len(chars) == 0: return False
if not chars[0].isdigit(): return False
chars.pop(0)
# check first letter after the digit
if len(chars) == 0: return False
if not chars[0].isalpha(): return False
chars.pop(0)
# return true if of the form lldl or llldl
if len(chars) == 0: return True
# check second letter after the digit
if not chars[0].isalpha(): return False
chars.pop(0)
# return true if of the form lldll or llldll
if len(chars) == 0: return True
# check third letter after the digit
if not chars[0].isalpha(): return False
chars.pop(0)
# return true if of the form lldlll or llldlll
if len(chars) == 0: return True
# if there is more input, then it's not a valid userid
return False
CS 3100
Data Structures and Algorithms 2
Reductions
Aaron Bloomfield (aaron@virginia.edu)
Raymond Pettit (raymond.pettit@virginia.edu)
@github | ↑ | 
Network Flow
Question: What is the maximum throughput of the railroad network from Omaha (OMA, far left) to Boston (BBY, far right)?
Flow Networks
|
|
|
Max flow intuition: If \(\color{purple}s\) is a faucet, \(\color{Blue}t\) is a drain, and \(\color{purple}s\) connects to \(\color{Blue}t\) through a network of pipes \(E\) with capacities \(\color{green}c(e)\), what is the maximum amount of water which can flow from the faucet to the drain?
Network Flow
flow / capacity
- Assignment of values \(\color{red}f(e)\) to edges
- “Amount of water going through that pipe”
- Capacity constraint
- \({\color{red}f(e)} \le {\color{green}c(e)}\)
- “Flow cannot exceed capacity”
- Flow constraint
- \(\forall v \in V - \{ {\color{purple}s},{\color{Blue}t}\}\), \(\text{inflow}(v)=\text{outflow}(v)\)
- \(\text{inflow}(v)=\sum_{x \in V}f(x,v)\)
- \(\text{outflow}(v)=\sum_{x \in V}f(v,x)\)
- Water going in must match water coming out
- Flow of \(G\): \(|f|=\text{outflow}({\color{purple}s})-\text{inflow}({\color{purple}s})\)
- Net outflow of \(\color{purple}s\)
- 3 in this example
Maximum Flow Problem
Of all valid flows through the graph, find the one that maximizes:
\[|f|=\text{outflow}({\color{purple}s})-\text{inflow}({\color{purple}s})\]
|
|
|
Greedy Approach
Greedy choice: saturate highest capacity path first
Greedy Approach
Greedy choice: saturate highest capacity path first
Greedy Approach
Greedy choice: saturate highest capacity path first
Flow: 20
Greedy Approach
Greedy choice: saturate highest capacity path first
Maximum flow: 30
Observe: highest capacity path is not saturated in optimal solution
Residual Graphs
|
Given a flow \(f\) in graph \(G\), the residual graph \(G_{\color{red}f}\) models additional flow that is possible
|
|
|
|
|
Flow \(\color{red}f\) in \(G\) |
Residual graph \(G_{\color{red}f}\) |
Residual Graphs
|
Given a flow \(f\) in graph \(G\), the residual graph \(G_{\color{red}f}\) models additional flow that is possible
|
|
|
|
|
Flow \(\color{red}f\) in \(G\) |
Residual graph \(G_{\color{red}f}\) |
Residual Graphs Example
| Flow Graph | Residual Graph |
|
|
|
|
|
|
Residual Graphs
|
Consider a path from \({\color{purple}s} \rightarrow {\color{Blue}t}\) in \(G_{\color{red}f}\) using only edges with positive (non-zero) weight Consider the minimum-weight edge along the path: we can increase the flow by \(w(e)\) |
|
|
|
|
Observe: Flow has increased by \(w(e)\) |
|
|
|
|
Residual Graphs
|
Consider a path from \({\color{purple}s} \rightarrow {\color{Blue}t}\) in \(G_{\color{red}f}\) using only edges with positive (non-zero) weight Consider the minimum-weight edge along the path: we can increase the flow by \(w(e)\) |
|
|
|
|
Observe: Flow has increased by \(w(e)\) |
|
|
|
|
Residual Graphs
|
Consider a path from \({\color{purple}s} \rightarrow {\color{Blue}t}\) in \(G_{\color{red}f}\) using only edges with positive (non-zero) weight Consider the minimum-weight edge along the path: we can increase the flow by \(w(e)\) |
|
|
|
|
Observe: Flow has increased by \(w(e)\) |
|
|
|
|
Ford-Fulkerson Example
|
Increase flow by 1 unit |
|
|
|
|
| Initially: \({\color{red}f(e)}=0\) for all \(e \in E\) | Residual graph \(G_{\color{red}f}\) |
Ford-Fulkerson Example
|
Increase flow by 1 unit |
|
|
|
|
| Residual graph \(G_{\color{red}f}\) |
Ford-Fulkerson Example
|
Increase flow by 1 unit |
|
|
|
|
| Residual graph \(G_{\color{red}f}\) |
Ford-Fulkerson Example
|
Increase flow by 1 unit |
|
|
|
|
| Residual graph \(G_{\color{red}f}\) |
Ford-Fulkerson Example
|
Increase flow by 1 unit |
|
|
|
|
| Residual graph \(G_{\color{red}f}\) |
Ford-Fulkerson Example
|
Increase flow by 1 unit |
|
|
|
|
| Residual graph \(G_{\color{red}f}\) |
Ford-Fulkerson Example
|
Increase flow by 1 unit |
|
|
|
|
| Residual graph \(G_{\color{red}f}\) |
Ford-Fulkerson Example
|
Increase flow by 1 unit |
|
|
|
|
| Residual graph \(G_{\color{red}f}\) |
Ford-Fulkerson Example
|
Increase flow by 1 unit |
|
|
|
|
| Residual graph \(G_{\color{red}f}\) |
Ford-Fulkerson Example
|
Increase flow by 1 unit |
|
|
|
|
| Residual graph \(G_{\color{red}f}\) |
Ford-Fulkerson Example
|
Increase flow by 1 unit |
|
|
|
|
| Residual graph \(G_{\color{red}f}\) |
Ford-Fulkerson Example
|
Increase flow by 1 unit |
|
|
|
|
| Residual graph \(G_{\color{red}f}\) |
Ford-Fulkerson Example
|
No more augmenting paths |
|
|
|
|
| Residual graph \(G_{\color{red}f}\) |
Maximum flow: 4
Worst Case Ford-Fulkerson
|
Increase flow by 1 unit |
|
|
|
|
Worst Case Ford-Fulkerson
|
Increase flow by 1 unit |
|
|
|
|
Worst Case Ford-Fulkerson
|
Increase flow by 1 unit |
|
|
|
|
Worst Case Ford-Fulkerson
|
Increase flow by 1 unit |
|
|
|
|
Worst Case Ford-Fulkerson
|
Increase flow by 1 unit |
|
|
|
|
Worst Case Ford-Fulkerson
|
Increase flow by 1 unit |
|
|
|
|
Worst Case Ford-Fulkerson
|
Increase flow by 1 unit |
|
|
|
|
Worst Case Ford-Fulkerson
|
Increase flow by 1 unit |
|
|
|
|
Observation: each iteration increases flow by 1 unit
Total number of iterations: \(|f^*|=200\)
Reminder: Graph Cuts
A cut of a graph \(G=(V,E)\) is a partition
of the nodes into two sets, \(\color{brown}S\) and \(\color{cornflowerblue}V-S\)
|
|
An edge \(\color{purple}(v_1,v_2) \in E\) crosses a |
An edge \(\color{green}(v_1,v_2) \in E\) respects a |
Showing Correctness of Ford-Fulkerson
- Consider cuts which separate nodes \(\color{purple}s\) and \(\color{Blue}t\)
- Let \({\color{purple}s} \in {\color{magenta}S}, {\color{Blue}t} \in {\color{skyblue}T}\) such that \(V={\color{magenta}S} \bigcup {\color{skyblue}T}\)
- Cost of cut \(({\color{magenta}S}, {\color{skyblue}T}) = ||{\color{magenta}S}, {\color{skyblue}T} ||\)
- Sum capacities of edges which go from \({\color{magenta}S}\) to \({\color{skyblue}T}\)
- This example: 5
|
|
Maxflow \(\le\) MinCut
- Max flow upper bounded by any cut separating \(\color{purple}s\) and \(\color{Blue}t\)
- Why? “Conservation of flow”
- All flow exiting \(\color{purple}s\) must eventually get to \(\color{Blue}t\)
- To get from \(\color{purple}s\) to \(\color{Blue}t\), all “pipes” must cross the cut
- Conclusion: if we find the minimum-cost cut, we’ve found the max flow
- \(\max_f|f| \le \min_{ {\color{magenta}S}, {\color{skyblue}T}}||{\color{magenta}S}, {\color{skyblue}T}||\)
|
|
Example: Maxflow/Mincut
| Flow Graph \(G\) | Residual graph \(G_{\color{red}f}\) |
|
|
|
| \(|f|=4\) | No more augmenting paths |
| \(||{\color{magenta}S}, {\color{skyblue}T} ||=4\) |
Idea: When there are no more augmenting paths, there
exists a cut in the graph with cost matching the flow
Proof: Maxflow/Mincut Theorem
- If \(|f|\) is a max flow, then \(G_{\color{red}f}\) has no augmenting path
- Otherwise, use that augmenting path to “push” more flow
- Define \({\color{magenta}S}=\) nodes reachable from source node \(\color{purple}s\) by positive-weight edges in the residual graph
- \({\color{skyblue}T}=V-{\color{magenta}S}\)
- \({\color{magenta}S}\) separates \({\color{purple}s},{\color{Blue}t}\) (otherwise there’s an augmenting path)
| Flow Graph \(G\) | Residual graph \(G_{\color{red}f}\) |
|
|
|
Proof: Maxflow/Mincut Theorem
- To show: \(||{\color{magenta}S},{\color{skyblue}T}||=|f|\)
- Weight of the cut matches the flow across the cut
- Consider edge \(\color{forestgreen}(u,v)\) with \(u \in {\color{magenta}S},v \in {\color{skyblue}T}\)
- \({\color{red}f(u,v)}={\color{forestgreen}c(u,v)}\) because otherwise \({\color{forestgreen}w(u,v)}>0\) in \(G_{\color{red}f}\), which would mean \(v \in {\color{magenta}S}\)
- Consider edge \(\color{brown}(y,x)\) with \(y \in {\color{skyblue}T}, x \in {\color{magenta}S}\)
- \({\color{red}f(y,x)}=0\) because otherwise the back edge \({\color{brown}w(y,x)}>0\) in \(G_{\color{red}f}\), which would mean \(y \in {\color{magenta}S}\)
| Flow Graph \(G\) | Residual graph \(G_{\color{red}f}\) |
|
|
|
Edge-Disjoint Paths
Given a graph \(G=(V,E)\), a start node \({\color{purple}s}\) and a destination node \({\color{Blue}t}\), give the maximum number of paths from \({\color{purple}s}\) to \({\color{Blue}t}\) which share no edges
Edge-Disjoint Paths
Given a graph \(G=(V,E)\), a start node \({\color{purple}s}\) and a destination node \({\color{Blue}t}\), give the maximum number of paths from \({\color{purple}s}\) to \({\color{Blue}t}\) which share no edges
- Set of edge-disjoint paths of size 3:
Edge-Disjoint Paths
Given a graph \(G=(V,E)\), a start node \({\color{purple}s}\) and a destination node \({\color{Blue}t}\), give the maximum number of paths from \({\color{purple}s}\) to \({\color{Blue}t}\) which share no edges
- Set of edge-disjoint paths of size 4:
- How could we solve this?
Edge-Disjoint Paths
Make \({\color{purple}s}\) and \({\color{Blue}t}\) the source and sink, give each edge capacity 1, find the max flow.
- Set of edge-disjoint paths of size 4
- Max flow = 4
Edge-Disjoint Paths
Make \({\color{purple}s}\) and \({\color{Blue}t}\) the source and sink, give each edge capacity 1, find the max flow.
- Set of edge-disjoint paths of size 4
- Max flow = 4
Vertex-Disjoint Paths
Given a graph \(G=(V,E)\), a start node \({\color{purple}s}\) and a destination node \({\color{Blue}t}\), give the maximum number of paths from \({\color{purple}s}\) to \({\color{Blue}t}\) which share no vertices
Vertex-Disjoint Paths
Given a graph \(G=(V,E)\), a start node \({\color{purple}s}\) and a destination node \({\color{Blue}t}\), give the maximum number of paths from \({\color{purple}s}\) to \({\color{Blue}t}\) which share no vertices
- Not a vertex-disjoint path!
Vertex-Disjoint Paths
Given a graph \(G=(V,E)\), a start node \({\color{purple}s}\) and a destination node \({\color{Blue}t}\), give the maximum number of paths from \({\color{purple}s}\) to \({\color{Blue}t}\) which share no vertices
- Not a vertex-disjoint path!
- How could we solve this?
Vertex-Disjoint Paths
Idea: Convert an instance of the vertex-disjoint paths problem into an instance of edge-disjoint paths
Make two copies of each node, one connected to incoming edges, the other to outgoing edges
Compute Edge-Disjoint Paths on new graph
Maximum Bipartite Matching
|
|
|
Maximum Bipartite Matching
|
|
|
Maximum Bipartite Matching
|
|
|
Maximum Bipartite Matching
|
|
|
Maximum Bipartite Matching
|
How could |
Maximum Bipartite Matching Using Max Flow
Make \(G=(L,R,E)\) a flow network \(G=(V,E)\) by:
|
|
Maximum Bipartite Matching Using Max Flow
Make \(G=(L,R,E)\) a flow network \(G=(V,E)\) by:
|
Total: \(\Theta(E \cdot V)\) |
Reductions
Shows how two different problems relate to each other
|
MOVIE TIME!
|
|
|
|
MacGyver’s Reduction
| Problem we don’t know how to solve | Problem we do know how to solve | |||||||||||||||||||
|
|
|
|
|
|
||||||||||||||||
Bipartite Matching Reduction
| Problem we don’t know how to solve | Problem we do know how to solve | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
|
|
|
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Edge Disjoint Paths Reduction
| Problem we don’t know how to solve | Problem we do know how to solve | ||||||||||||||||
|
|
|
|
|
|
|||||||||||||
Vertex Disjoint Paths Reduction
| Problem we don’t know how to solve | Problem we do know how to solve | ||||||||||||||||
|
|
|
|
|
|
|||||||||||||
Vertex Disjoint Paths Big Picture
| Problem we don’t know how to solve | Problem we still don’t know how to solve | Problem we do know how to solve | |||||||||||||||||||||||||||
|
|
|
|
|
|
|
|
|
||||||||||||||||||||||
In General: Reduction
|
|
|
Another use of Reductions
|
|
|
Worst case lower bound Proofs
|
|
|
|
|
||||||||
|
|
|
|
|
||||||||
\(A\) is not harder than problem \(B\): \(A \le B\)
The name “reduces” is confusing: it is in the opposite direction of the making
Proof of Lower Bound by Reduction
|
To show: \(Y\) is slow |
||
|
|
|
|
|
|
|
|
|
|
|
|
|
||
Reduction Proof Notation
|
|
|
||||
|
With \(O(f(n))\) overhead |
|
\(A\) is not harder than problem \(B\)
\(A \le B\)
If \(A\) requires time \(\Omega(f(n))\) time then \(B\) also requires time \(\Omega(f(n))\)
\(A \le_{f(n)}B\)
Two Ways to Use Reductions
Suppose we have a “fast” reduction from \(A\) to \(B\)
|
A “fast” algorithm for \(B\) gives a fast algorithm for \(A\)
| Then \(\color{red}A\) is fast |
|
If \(\color{orange}B\) is fast |
If we have a worst-case lower bound for \(A\), we also have one for \(B\)
| If \(\color{red}A\) is slow |
|
Then \(\color{orange}B\) is slow |
Bipartite Matching Reduction
| Problem we don’t know how to solve | Problem we do know how to solve | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
|
|
|
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
|
|
Reductions for Lower-Bound Proofs
|
|
|
Reductions for Lower-Bound Proofs
|
|
|
Reductions for Lower Bound on CPP
|
|
|
Two Ways to Use Reductions
Suppose we have a “fast” reduction from \(A\) to \(B\)
|
|
A “fast” algorithm for \(B\) gives a fast algorithm for \(A\)
| Then \(\color{red}A\) is fast |
|
If \(\color{orange}B\) is fast |
If we have a worst-case lower bound for \(A\), we also have one for \(B\)
| If \(\color{red}A\) is slow |
|
Then \(\color{orange}B\) is slow |
Party Problem
|
Draw edges between people who don’t get along
Find the maximum number of people who get along |
Example
| Independent set of size 6 |
Generalized Baseball
Generalized Baseball
|
Need to place defenders on bases such that every edge is defended What’s the fewest number of defenders needed? |
Generalized Baseball
|
Vertex cover of size 5 |
MaxIndSet \(\le_V\) MinVertCover
Problem \(A\)
\(O(V)\) reduces to
Problem \(B\)
Algorithm for \(B\)
can be used to make
Algorithm for \(A\)
If \(A\) requires \(\Omega(f(n))\) time, then \(B\) also requires \(\Omega(f(n))\) time
\[A \le_V B\]
Reduction Idea
\(S\) is an independent set of \(G\) iff \(V-S\) is a vertex cover of \(G\)
Independent Set
Vertex Cover
Reduction Idea
\(S\) is an independent set of \(G\) iff \(V-S\) is a vertex cover of \(G\)
Independent Set
Vertex Cover
MinVertCov \(V\)-time reducible to MaxIndSet
| Problem we don’t know how to solve | Problem we do know how to solve | ||||||||||||||||||||||
|
|
|
|
|
|||||||||||||||||||
Proof: ⇐
\(\color{red}S\) is an independent set of \(G\) iff \(V-S\) is a vertex cover of \(G\)
Let \(\color{red}S\) be an independent set
Consider any edge \({\color{magenta}(x,y)} \in E\)
If \(\color{red}x\in S\), then \(y \notin S\) because otherwise \(\color{red}S\) would not be an independent set
Therefore \(y \in V-S\), so edge \({\color{magenta}(x,y)}\) is covered by \(V-S\)
Proof: ⇒
\(S\) is an independent set of \(G\) iff \(V-S\) is a vertex cover of \(G\)
Let \(\color{red}V-S\) be a vertex cover
Consider any edge \({\color{magenta}(x,y)} \in E\)
At least one of \(\color{red}x\) and \(\color{cornflowerblue}y\) belong to \(\color{red}V-S\) because \(\color{red}V-S\) is a vertex cover of \(G\)
Therefore \(\color{red}x\) and \(\color{cornflowerblue}y\) are not both in \(\color{cornflowerblue}S\)
No edge has both end nodes in \(\color{cornflowerblue}S\), thus \(\color{cornflowerblue}S\) is an independent set
MaxIndSet \(V\)-time reducible to MinVertCov
| Problem we don’t know how to solve | Problem we do know how to solve | ||||||||||||||||||||||
|
|
|
|
|
|||||||||||||||||||
|
|
MinVertCov \(V\)-time reducible to MaxIndSet
| Problem we don’t know how to solve | Problem we do know how to solve | |||||||||||||||||||||||
|
|
|
|
|
||||||||||||||||||||
|
|
Automata
Let’s phrase this using a finite state machine
- Each arrow assumes that it pops (consumes) one character
- Double circled states are final states
- If the end of input is in a final state, the string is accepted
Automata
What if we only have one accepting (aka final) state?
- But which way to go?
- In state 2, on a input of a letter, we could go to two different states: 3 or 8 (likewise for states 3, 5, and 6)
- This is called non-determinism
Automata
The same automata as the last slide, but laid out differently
Automata
This has empty (\(\epsilon\)) transitions; only allowed on NFAs
Automata and languages
- How would you write an automata that can accept strings with some positive number of a’s followed by some positive number of b’s?
- Expressed as \(a^+b^+\)
More powerful automata
- How would you write an automata that can accept strings with some positive number of a’s followed by the same number of b’s?
- Expressed as \(a^nb^n\)
- Answer: you can’t. Any finite automata of \(n\) states cannot accept a string of \(n+1\) a’s (and \(n+1\) b’s)
Accepting \(a^nb^n\)
- To accept these strings, you need memory: how many a’s have been accepted
- This is done via a stack
- On each a, push a value onto the stack
- On each b, pop a value from the stack
- Ensure the stack is empty at the end
- This is called a push-down automata
- The range of languages (strings) that these can produce (aka accept) are called context-free languages
Yet even more powerful automata
- What about a programming language?
- This needs a Turing machine, which can compute anything a computer can compute
- Such languages are called recursively enumerable languages
Turing Machines
- A Turing machine has a NFA (or DFA) as it’s “control”
- A computer’s current memory state is, in effect, a DFA state
- And an infinite tape that it can read and write values to
- Analogous to a computer’s memory
- (image from texexample.net)
NFA Animation
- Back to our NFA to accept UVA userids
- Imagine that this is the NFA in a Turing machine
- Although this one does not use memory
- We’ll trace through accepting any valid UVA userid
- Goal: what states can the NFA be in at any step?
NFA Animation
Complexity classes
- P: Any problem that can be solved by a deterministic finite automata (DFA) in polynomial time
- Solution can be verified in polynomial time
- NP: Any problem that can be solved by a non-deterministic finite automata (NFA) in polynomial time
- Might take exponential time on a DFA
- Solution can be verified in polynomial time
- If a problem can be solved by a DFA in polynomial time, then it can be solved by an NFA in polynomial time
- Thus, \({\color{forestgreen}P} \subset {\color{blue}NP}\)
Complexity classes
- NP-hard
- A problem that is at least as difficult as NP
- Could be more difficult, but not less difficult
- A problem that is at least as difficult as NP
- There are believed to be problems in NP that are not NP-hard (none yet proven)
There are actually many more complexity classes:
Complexity classes
- NP-complete
- A set of problems that are of equivalent difficulty as SAT
- We show problem \(X\) is NP-complete by:
- Reducing SAT (or another NP-complete problem) to \(X\)
- Reducing \(X\) to SAT (or another NP-complete problem)
- But if \(X \in {\color{blue}NP}\), then it reduces to SAT via the Cook-Levin theorem
- So we just have to show \(X \in {\color{blue}NP}\)
Example reduction: Vertex Cover
- Consider the minimum vertex cover problem:
- Given a graph \(G=(V,E)\), find a set of vertices \(C\subseteq V\) such that every edge in \(E\) has at least one endpoint in \(C\)
- To prove it’s NP-complete:
- Show it’s in NP (this means it reduces to SAT)
- \(VC \in {\color{blue}NP} \equiv VC \le_p SAT\)
- Reduce a known NP-complete problem to it
- \(SAT \le_p VC\)
- Show it’s in NP (this means it reduces to SAT)
Why we can’t just reduce \(X\) to SAT
|
|
|
- Consider the problem of finding a bipartite matching (not necessarily maximal)
- Reduce it to SAT:
- Create a set of clauses for the possible matchings: \(bloomfied \wedge husky\), \(pettit \wedge labrador\), etc.
- But also ensure one dog per person:
\(bloomfied \wedge husky \wedge \neg labrador \wedge \neg dachshund \wedge \neg jonangi\) - Likewise ensure one human per dog
- But also ensure one dog per person:
- OR all these clauses together
- Negate, via DeMorgan’s Law, into conjunctive normal form
- Create a set of clauses for the possible matchings: \(bloomfied \wedge husky\), \(pettit \wedge labrador\), etc.
- Solve using SAT
- Solution: DeMorgan-ize it again out of conjunctive normal form, and examine the clauses with the correct pairings
Why we can’t just reduce \(X\) to SAT
|
|
|
What did we just show?
- That non-maximal bipartite matching can be reduced to SAT
- But non-maximal bipartite matching is much easier than SAT!
- A non-maximal matching can be done in \(O(V)\) time: go through the left nodes, and assign them to an arbitrary right node that is not yet assigned
- This doesn’t show that non-maximal bipartite matching is as difficult as SAT
- Only that SAT is more difficult than non-maximal bipartite matching
Complexity classes
