# Np Complete Vs Np Hardclevelandmultifiles

In computational complexity theory, a problem is NP-complete when:. A nondeterministic Turing machine can solve it in polynomial-time.; A deterministic Turing machine can solve it in large time complexity classes (e.g., EXPTIME, as is the case with brute force search algorithms) and can verify its solutions in polynomial time. NP deals with the gap between computers being able to quickly solve problems vs. Just being able to test proposed solutions for correctness. As such, the P vs. NP problem is the search for a way to solve problems that require the trying of millions, billions, or trillions of combinations without actually having to try each one.

- Np Complete Vs Np Hardclevelandmultifiles Test
- Np Complete Vs Np Hardclevelandmultifiles Pharmacology
- Np Complete Vs Np Hardclevelandmultifiles Prescriptive
- Np Complete Vs Np Hardclevelandmultifiles Exam

- Design and Analysis of Algorithms

- Basics of Algorithms

- Design Strategies

- Graph Theory

- Heap Algorithms

- Sorting Methods

- Complexity Theory

- DAA Useful Resources

- Selected Reading

A problem is in the class NPC if it is in NP and is as **hard** as any problem in NP. A problem is **NP-hard** if all problems in NP are polynomial time reducible to it, even though it may not be in NP itself.

If a polynomial time algorithm exists for any of these problems, all problems in NP would be polynomial time solvable. These problems are called **NP-complete**. The phenomenon of NP-completeness is important for both theoretical and practical reasons.

## Definition of NP-Completeness

A language **B** is ** NP-complete** if it satisfies two conditions

**B**is in NPEvery

**A**in NP is polynomial time reducible to**B**.

If a language satisfies the second property, but not necessarily the first one, the language **B** is known as **NP-Hard**. Informally, a search problem **B** is **NP-Hard** if there exists some **NP-Complete** problem **A** that Turing reduces to **B**.

The problem in NP-Hard cannot be solved in polynomial time, until **P = NP**. If a problem is proved to be NPC, there is no need to waste time on trying to find an efficient algorithm for it. Instead, we can focus on design approximation algorithm.

## NP-Complete Problems

Following are some NP-Complete problems, for which no polynomial time algorithm is known.

- Determining whether a graph has a Hamiltonian cycle
- Determining whether a Boolean formula is satisfiable, etc.

## NP-Hard Problems

The following problems are NP-Hard

- The circuit-satisfiability problem
- Set Cover
- Vertex Cover
- Travelling Salesman Problem

In this context, now we will discuss TSP is NP-Complete

## Np Complete Vs Np Hardclevelandmultifiles Test

## TSP is NP-Complete

The traveling salesman problem consists of a salesman and a set of cities. The salesman has to visit each one of the cities starting from a certain one and returning to the same city. The challenge of the problem is that the traveling salesman wants to minimize the total length of the trip

## Proof

To prove ** TSP is NP-Complete**, first we have to prove that

**. In TSP, we find a tour and check that the tour contains each vertex once. Then the total cost of the edges of the tour is calculated. Finally, we check if the cost is minimum. This can be completed in polynomial time. Thus**

*TSP belongs to NP***.**

*TSP belongs to NP*Secondly, we have to prove that ** TSP is NP-hard**. To prove this, one way is to show that

**(as we know that the Hamiltonian cycle problem is NPcomplete).**

*Hamiltonian cycle ≤*_{p}TSPAssume ** G = (V, E)** to be an instance of Hamiltonian cycle.

Hence, an instance of TSP is constructed. We create the complete graph ** G^{'} = (V, E^{'})**, where

$$E^{'}=lbrace(i, j)colon i, j in V ::and:ineq j$$

Thus, the cost function is defined as follows −

$$t(i,j)=begin{cases}0 & if: (i, j): in E1 & otherwiseend{cases}$$

Now, suppose that a Hamiltonian cycle ** h** exists in

**. It is clear that the cost of each edge in**

*G***is**

*h***0**in

**as each edge belongs to**

*G*^{'}**. Therefore,**

*E***has a cost of**

*h***0**in

**. Thus, if graph**

*G*^{'}**has a Hamiltonian cycle, then graph**

*G***has a tour of**

*G*^{'}**0**cost.

Conversely, we assume that ** G^{'}** has a tour

**of cost at most**

*h*^{'}**0**. The cost of edges in

**are**

*E*^{'}**0**and

**1**by definition. Hence, each edge must have a cost of

**0**as the cost of

**is**

*h*^{'}**0**. We therefore conclude that

**contains only edges in**

*h*^{'}**.**

*E*We have thus proven that ** G** has a Hamiltonian cycle, if and only if

**has a tour of cost at most**

*G*^{'}**0**. TSP is NP-complete.

This is a rough guide to the meaning of 'NP-Complete'. It is not intended to be an exact definition, but should help you to understand the concept.

These are just my personal ideas and are not meant to be 'rigorous'.

## Its All About 'Time to Solve'

When you measure how long a program takes to run when it is given more and more difficult problems (such as sorting a list of 10 items, 20 items, 30 items etc) you can plot the times and come up with a function.

### Example: a program's time increases by x^{2}

So a problem that is twice as hard takes 4 times as long.

That program is in 'P', as it is solvable in 'Polynomial' time.

In this case the polynomial is:

**t = x ^{2}**

But if the time goes up exponentially or factorially, or something that exceeds what a polynomial can do, it is NOT in 'P' (it is not solvable in 'Polynomial' time).

**P**: can be solved in **P**olynomial time.

(How long it takes is defined by a polynomial)

## Amazing Computer can do what normal Computers can't

Now, the 'N' in 'NP' refers to the fact that you are not bound by the normal way a computer works, which is step-by-step. The 'N' actually stands for 'Non-deterministic'. This means that you are dealing with an amazing kind of computer that can run things simultaneously or could somehow guess the right way to do things, or something like that.

So this 'N' computer can solve lots more problems in 'P' time - for example it can just clone copies of itself when needed.

It is not a Super Computer (they are just very fast normal computers), it is really a 'Non-deterministic' computer, but I am calling it an Amazing Computer to give you the idea!

So, programs that take dramatically longer as the problem gets harder (i.e. not in 'P') could be solved quickly on this amazing 'N' computer and so are in 'NP'. Thus 'NP' means 'we can solve it in polynomial time if we can break the normal rules of step-by-step computing'.

**NP**: can be solved in **P**olynomial time using a ** N**on-deterministic method.

(also includes

**P**problems)

## Amazing Computers can also do what normal Computers can

Since this amazing 'N' computer can also do anything a normal computer can, we know that 'P' problems are also in 'NP'.

So, the easy problems are in 'P' (and 'NP'), but the **really hard ones** are *only* in 'NP', and they are called 'NP-complete'.

It is like saying there are things that People can do ('P'), there are things that SuperPeople can do ('SP'), and there are things *only* SuperPeople can do ('SP-complete').

**NP-Complete**: can be solved in **P**olynomial time**only** using a **N**on-deterministic method.

## NP-Complete may not last

Oh, one more thing, it is believed that if anyone could *ever* solve an 'NP-Complete' problem in 'P' time, then *all* 'NP-complete' problems could also be solved that way by using the same method, and the whole class of 'NP-Complete' would cease to exist.

## Traveling Salesman Problem

The classic example of 'NP-Complete' problems is the Traveling Salesman Problem.

Imagine you need to visit 5 cities on your sales tour. You know all the distances. Which is the shortest round-trip to follow? ABCEDA? ADECBA?

An obvious solution is to check all possibilities.

But this only works for small problems. If you add a new city it needs to be tried out in every previous combination.

So this method takes 'factorial time': **t = n!**

(Actually **t = (n-1)!** but it is still factorial.)

Imagine the program solves a 20-city problem in 1 second, then

- a 21-city problem will take about 21 seconds to solve.
- And a 22-city problem will take about 462 seconds (over 7 minutes),
- and a 30-city problem will take 3 Million Years. Ouch!

Luckily, there are special ways to break the problem into sub-problems (called 'dynamic programming', but the best still take exponential time: **t = 2 ^{n}**

*(2 with an exponent of n)*

So a program that solves 20 cities in 1 second will solve 30-cities in about 10 minutes, and 60-cities in about 35,000 Years (still a bit too long).

But if we had the 'Amazing Computer' mentioned above it could, for example, create copies of itself to check all the possibilities, and hopefully solve the problem very quickly.

## NP-Hard

## Np Complete Vs Np Hardclevelandmultifiles Pharmacology

When a problem's method for solution can be turned into an **NP-Complete** method for solution it is said to be 'NP-Hard'.

## Np Complete Vs Np Hardclevelandmultifiles Prescriptive

**NP-Hard**: as hard as any NP-problem, or maybe harder.

## Np Complete Vs Np Hardclevelandmultifiles Exam

Anyway, I hope this 'quick and dirty' introduction has helped you ... now go and read something more rigorous.