Your claim that you can convert an arbitrary formula to DNF in polynomial time is mistaken.
You can convert a boolean formula into DNF, but the resulting formula might be very much larger than the original formula—in fact, exponentially so. Since the conversion algorithm must at the very least write out the resulting DNF formula, its running time must be at least the length of the output, and therefore its worst-case running time must be exponential.
Even if you somehow finesse the issue of writing out the DNF version of the input formula, the algorithm you propose takes a formula of size $x$, converts it into a DNF formula of worst-case size $2^x$, and then calculates satisfiability of the DNF formula in time $P(2^x)$ for some polynomial $P$. This is no better in general than just trying every possible satisfying assignment in the original formula.
The Wikipedia article on "Disjunctive Normal Form" has an example of a formula that explodes when converted to DNF. But it's an easy example. Consider:
$$(A_1\lor B_1)\land(A_2\lor B_2)\land\cdots\land(A_n\lor B_n)$$
This has length proportional to $n$. But in DNF it turns into:
$$(A_1\land A_2\land\cdots\land A_n)\lor\\
(B_1\land A_2\land\cdots\land A_n) \lor \\
(A_1\land B_2\land\cdots\land A_n) \lor \\
(B_1\land B_2\land\cdots\land A_n) \lor \\
\vdots\\
(B_1\land B_2\land\cdots\land B_n)\hphantom{\lor}
$$
with $2^n$ clauses.
A language $L$ is “NP-complete” if $L$ belongs to NP, and every language $X$ in NP can be polynomial-time reduced to $L$; that is the definition of “NP-complete”.
How might we show that every problem $X$ in NP can be reduced to $L$?
Well, $X$ is in NP, and the only thing we have to work with here is the definition of NP:
There is a nondeterministic Turing machine $M$ which,
given a string $I$,
correctly decides in polynomial time
whether $I$ is in $X$.
Cook's theorem takes $M$ and a specific $I$ and constructs a large (but polynomial) family of statements that are satisfiable if, and only if, $M$ will accept $I$.
The statements do this because they completely describe the exact computation that $M$ would perform starting with string $I$, including an assertion that $M$ would end in an accepting state.
Because of the way the statements are constructed, they can be satisfied if, and only if, $M$ would actually perform a computation that ends by accepting $I$.
If there is no such computation, the clauses are not satisfiable.
So we have this large (but polynomial) family of statements which are satisfiable if, and only if, the machine $M$, which correctly recognizes the language $X$, would accept the particular string $I$.
If we had a satisfying assignment for those statements, that satisfying assignment would exactly describe what $M$ would do in accepting $I$: it would say how $M$ would move its head, and how it would modify the tape over time, and so on, and it would also describe the fact that $M$ would terminate in an accepting state.
So if we could find a satisfying assignment for this large family of statements, we would know that $I$ was in $X$, because we would have a complete description of how the machine $M$, which recognizes $X$, would behave in accepting $I$.
If we could quickly find a satisfying assignment for this large (but polynomial) family of statements, we would be able to quickly decide whether any given $I$ was in $X$, as follows: We would take the string $I$. We would construct the large (but polynomial) family of statements that collectively describe $M$'s computation starting with $I$, including the assertion that $M$ would end in an accepting state. We would quickly check if those statements were satisfiable. If they were, we would know that $M$ would accept $I$; if not then not.
But if we could quickly find satisfying assignments, we could quickly solve every problem $X$ that is in NP, because for every such problem $X$ there is a machine $M$ that recognizes $X$. So an efficient solution to the satisfiability problem would give us an efficient solution to problem $X$ that was in NP. If $X$ is in NP, there is some machine $M$ that recognizes it, and then given any string $I$, we could do just as in the previous paragraph to quickly decide whether $I$ was in $X$.
So an efficient method for finding satisfying assignments can solve efficiently solve any problem $X$ in NP:
Take the machine $M$ that recognizes $X$, construct a set of statements that describe its computation starting from $I$, including the assertion that the computation would end in an accepting state, and then check if those statements can be satisfied. If so, then $I$ is in $X$.
I hope that was some help.
Best Answer
NP completeness is defined for yes-no questions. An instance of the partition problem is a question of the form: given these sets does there exist a partition. This is proved to be NP complete. Questions of the form: given these sets and a positive integer k does there exist a partition into less than k sets are also decision problems (and are also NP complete by reduction to partition). Questions of the form: Given these sets what is the smallest (or largest) size of a partition is not a decision problem, and so cannot be NP complete or not NP complete. A question of that form can be NP-Hard