Q(P,A)

{
for (x in A)
P(x);
return 1;
}

PO – P, w

PO – 1, daca P(w) se termina

- nu se termina, daca P(w) nu se termina

PO(P,w) <=T Q(P’,A)

1. functie de transformare a.i. oricarei intrare a problemei PO sa ii corespunnda o intrare pentru Q

P’ = P
A = {w}

2. PO(P,w) = 1 => P(w) se termina => Q(P’,A) se termina => Q(P’,A) =1

3. Q(P’,A) = 1 => pentru orice x din A, P(x) se termina, dar A = {w} => P(w) se termina =>
PO(P,w) = 1

Algoritmi nedeterminist polinomiali

NU stim daca se pot rezolva in timp polinomial

stim ca se pot rezolva in timp polinomial folosind operatii nedeterministe

x = choice(1...n)

x=1 x=2 x=3 x=n

y = choice(1..n)

x=1,y=1 x=1,y=2… x=n,y=n // n^2 threaduri

for i=1:n
v[i] = choice(1..n) // complexitate angelica O(n)
// n^n threaduri

success() - daca un thread da success(), programul intoarce success

fail()

2 tipuri de algoritmi NP:

- de decizie (da sau nu)
- de optim (sa se gaseasca un cost optim pentru o anumita proprietate)

Algoritmii de optim pot fi tratati ca mai multi algoritmi de decizie.

Ex: sa se gaseasca un ciclu intr-un graf care trece prin toate nodurile o singura data si are cost
minim

Se poate modela in felul urmator:

cost_maxim = cost_maxim_muchie * N = C

exista un ciclu de cost C? DA

Exista un ciclu de cost C-1? DA
Exista un ciclu de cost C-2?DA
…

Exista un ciclu de cost C-k? NU

=>
C-k+1

Alg1(V,n,k)
{
int start = choice(1..n-k) //generare
for (I = start+1; I<=start+k; i++)
if (v[i] != v[start])
fail()
success();
}

Alg2(M,N, dim,u,v)
{
if (M[u][v])
success();
// vreau sa generez u->n1->n2...->nk->v
for (i=1;i<=dim-2;i++)
{
V[] = new int[i];
for (j=1; j<=i; j++)
V[i] = choice(1..n)
flag = 1
if (M[u][V[1]] == 0)
flag = 0;
for (j=1; j<i; j++)
if (M[V[j]][V[j+1]] == 0)
{
flag =0;
break;
}
if (M[V[i]][v] == 0)
flag =0;
if (flag == 1)
success();
}
fail();
}
k_colorare(M,N,k)
{
color[] = new int[N];
for (i=1; i<=N; i++)
color[i] = choice(1...k)
for (i=1;i<=N; i++)
for (j=1; j<=N; j++)
if (M[i][j] && color[i] == color[j])
fail();
success();
}

k_clica(M,N,k)
{
V = {}
for (i=1; I<=k; i++)
{
x = choice(1..N)
if (x apartine V)
fail();
V = V U {x};
}
for (i=1; I<=k; i++)
for (j=1; j<=k; j++)
if (i!=j && M [V[ I] ] [V[j] ] == 0)
fail();
success();
}

vertex_cover(M,N,k)
{
V = {}
for (i=1; I<=k; i++)
{
x = choice(1..N)
if (x apartine V)
fail();
V = V U {x};
}
for (i=1; I<=n; i++)
for (j=1; j<=N; j++)
if ( M[i][j] && ! (i apartine V) && !(j apartine V) )
fail();
success();
}
Q_sume(A, N,Q)
{
if (Q == 0)
success();
for (i=1; I<=N; i++)
{
s=0
M = {}
for (j=1; j<= I; j++)
{
x = choice(1..N)
if (A[x] apartine M)
fail();
M = M U A[x];
s = s + A[x];
}
if (s == Q)
success();
}
fail();
}

TSP(M,N)
{
V[] = new int[N+1];
marcat[] = new int[N];
for (i=1; i<=N; i++)
{
x = choice(1...N);
if (marcat[x] == 1)
fail();
marcat[x] = 1;
V[i] = x;
}
V[N+1] = V[1];
for (i=1; I<=N; i++)
if (M [ V[i] ] [V [ i+1] ] == 0)
fail();
success();
}

N_Queen()
{
int V[] = new int[N];
for (i=1; I<=n; i++)
V[i] = choice(1...N)
for (i=1; I<=n; i++)
for (j=1; j<=n; j++)
if (i!=j)
if (V[i] == V[j] || abs(V[i]-i]) == abs(V[j]-j)) // se ataca pe diagonala
sau pe coloana
fail();
 success();
}

graph_isomorphism(N1,M1,N2,M2)
{
if (N1 < N2)
fail();
int V[] = new int [N2];
int marcat[] = new int[N1];
for (i=1; I<=N2; i++)
{
x = choice(1..N1);
if (marcat[x] ==1)
fail();
marcat[x] = 1;
V[i] = x;
}

for (i=1; I<=N2; i++)

for (j=1; j<=N2; j++)
if (M1[i][j] != M2[ V[i] ] [V[j] ])
fail();
success();
}

independent_set(N,M,k)
{
V = {}
for (i=1; I<=k; i++)
{
x = choice(1..N)
if (x apartine V)
fail();
V = V U {x};
}
for (i=1; I<=n; i++)
for (j=1; j<=N; j++)
if ( M[i][j] && i apartine V && j apartine V )
fail();
success();
}

partition(V,N)
{
if (sum(V) %2 == 1)
fail();
if (sum(V) == 0)
success();
 for (i=1; I<N; i++)
{
S1 = {}
s = 0;
for (j=1;j<=i;j++)
{
x = choice(1..N);
if (V[x] in S)
fail();
S = S U {V[x]};
s = s +V [x];
}
if (s == sum(V)/2)
success();
}
fail();
}

SAT(E, N)
{
X[] = new int[N];
for (i=1; I<=N; i++)
X[i]= choice{0..1};
for (i=0; I<E.length(); i++)
{
flag = 0;
for (j=0; j<E[i]. length(); j++)
if ( (E[i][j] >0 && X [E[i][j]] == 1) ||
(E[i][j] < 0 && X [-E[i][j]] == 0) )
flag = 1;
if (flag ==0)
fail();
}
success();
}

(x1 ∨ ¬x2) ∧ (¬x1 ∨x2 ∨ x3) ∧ ¬x1

[ [ 1,-2] [-1,2,3 ] [-1 ] ]