like when we solve a puzzle of Sudoku, we do hit and trial and then verify if we are wrong at this point. that's NP. we are not using and algorithm to fill the blanks, we are verifying and completing the grid.

hope this helps

The Gateway to Computer Science Excellence

0 votes

what i have tried to get out the conslusion for P problem is that

**P problem **

These are set of those yes/no problems which can solved using polynomic time complexity algroithms.

For example if are asked to Compare or sort then numbers.Then using loop we can solve and thus we can also derive its timecomplexity ie O(n) or O(nlogn)

**NP problem**

These are set of those yes/no problems which cannot be solved using polynomic time complexity algorithms.

These can be verified

For example Years ago generation of fire was problem and man was not able to decide whether fire can be invented or not and hence he was not able to conclude.

hence this type of problem could not be solved using polynomic time complexity algorithms.

but today when fire has came into existence this fact can be verified.hence this Np problem is now P problem

**Am i correct with these two terms ????????????????**

+1

NP problems are those where you can only verify your solution to be true or false.

like when we solve a puzzle of Sudoku, we do hit and trial and then verify if we are wrong at this point. that's NP. we are not using and algorithm to fill the blanks, we are verifying and completing the grid.

hope this helps

like when we solve a puzzle of Sudoku, we do hit and trial and then verify if we are wrong at this point. that's NP. we are not using and algorithm to fill the blanks, we are verifying and completing the grid.

hope this helps

+3 votes

Your P part is correct. But not the NP part.

First of all "N" in "NP" does not stand for "not". It is for "non-deterministic" (meaning with non-determinism such a problem can be solved in polynomial time). That is P and NP are not disjoint sets and in fact P is a subset of NP. (It is not yet known if P = NP but that we do not care here). We practically do not have a non-deterministic TM and that is why we currently cannot solve an NP problem not known to in P, in polynomial time.

These are set of those yes/no problems which cannot be solved using polynomial time complexity algorithms

As told above we cannot use "cannot". Because that makes no P problem an NP problem. But for a problem in NP not known to be in P, this is true. But in future this can be true for any such problem - for example, checking whether a given number is prime or not was not known to be P for a long time but recently IITK professors made a polynomial time algorithm for this moving this problem to P.

+1 vote

*P is a complexity class that represents the set of all decision problems that can be solved in polynomial time*. That is, given an instance of the problem, the answer yes or no can be decided in polynomial time.

**Example**

Given a graph connected `G`

, can its vertices be colored using two colors so that no edge is monochromatic?

Algorithm: start with an arbitrary vertex, color it red and all of its neighbours blue and continue. Stop when you run out of vertices or you are forced to make an edge have both of its endpoints be the same color.

*NP is a complexity class that represents the set of all decision problems for which the instances where the answer is "yes" have proofs that can be verified in polynomial time.*

This means that if someone gives us an instance of the problem and a certificate (sometimes called a witness) to the answer being yes, we can check that it is correct in polynomial time.

**Example**

*Integer factorisation* is in NP. This is the problem that given integers `n`

and `m`

, is there an integer `f`

with `1 < f < m`

, such that `f`

divides `n`

(`f`

is a small factor of `n`

)?

This is a decision problem because the answers are yes or no. If someone hands us an instance of the problem (so they hand us integers `n`

and `m`

) and an integer `f`

with `1 < f < m`

, and claim that `f`

is a factor of `n`

(the certificate), we can check the answer in *polynomial time* by performing the division `n / f`

.

*NP-Complete is a complexity class which represents the set of all problems X in NP for which it is possible to reduce any other NP problem Y to X in polynomial time.*

Intuitively this means that we can solve `Y`

quickly if we know how to solve `X`

quickly. Precisely, `Y`

is reducible to `X`

, if there is a polynomial time algorithm `f`

to transform instances `y`

of `Y`

to instances `x = f(y)`

of `X`

in polynomial time, with the property that the answer to `y`

is yes, if and only if the answer to `f(y)`

is yes.

**Example**

`3-SAT`

. This is the problem wherein we are given a conjunction (ANDs) of 3-clause disjunctions (ORs), statements of the form

```
(x_v11 OR x_v21 OR x_v31) AND
(x_v12 OR x_v22 OR x_v32) AND
... AND
(x_v1n OR x_v2n OR x_v3n)
```

where each `x_vij`

is a boolean variable or the negation of a variable from a finite predefined list `(x_1, x_2, ... x_n)`

.

It can be shown that *every NP problem can be reduced to 3-SAT*. The proof of this is technical and requires use of the technical definition of NP (*based on non-deterministic Turing machines*). This is known as *Cook's theorem*.

What makes NP-complete problems important is that if a deterministic polynomial time algorithm can be found to solve one of them, every NP problem is solvable in polynomial time (one problem to rule them all).

Intuitively, these are the problems that are *at least as hard as the NP-complete problems*. Note that NP-hard problems *do not have to be in NP*, and *they do not have to be decision problems*.

The precise definition here is that *a problem X is NP-hard, if there is an NP-complete problem Y, such that Y is reducible to X in polynomial time*.

But since any NP-complete problem can be reduced to any other NP-complete problem in polynomial time, all NP-complete problems can be reduced to any NP-hard problem in polynomial time. Then, if there is a solution to one NP-hard problem in polynomial time, there is a solution to all NP problems in polynomial time.

**Example**

The *halting problem* is an NP-hard problem. This is the problem that given a program `P`

and input `I`

, will it halt? This is a decision problem but it is not in NP. It is clear that any NP-complete problem can be reduced to this one. As another example, any NP-complete problem is NP-hard.

My favorite NP-complete problem is the Minesweeper problem.

This one is the most famous problem in computer science, and one of the most important outstanding questions in the mathematical sciences. In fact, the Clay Institute is offering one million dollars for a solution to the problem (Stephen Cook's writeup on the Clay website is quite good).

It's clear that P is a subset of NP. The open question is whether or not NP problems have deterministic polynomial time solutions. It is largely believed that they do not. Here is an outstanding recent article on the latest (and the importance) of the P = NP problem: The Status of the P versus NP problem.

The best book on the subject is Computers and Intractability by Garey and Johnson.

- All categories
- General Aptitude 1.9k
- Engineering Mathematics 7.5k
- Digital Logic 2.9k
- Programming and DS 4.9k
- Algorithms 4.4k
- Theory of Computation 6.2k
- Compiler Design 2.1k
- Databases 4.1k
- CO and Architecture 3.4k
- Computer Networks 4.2k
- Non GATE 1.4k
- Others 1.4k
- Admissions 595
- Exam Queries 573
- Tier 1 Placement Questions 23
- Job Queries 72
- Projects 18

50,737 questions

57,365 answers

198,494 comments

105,261 users