11

(
): (greedy), (divide
and conquer), (dynamic programming),
(randomized) (backtracking).

11.1

:
:
. , .
:
.
,

. , ,
.
,
( ,
), ( ,
), .

,
T(n) = 2T(n/2) + O(n)
O(n log n).
1
.
:
a[0..n] a[0..m] a[m+1..n],
(),
. ,
. ,
, 1.



static int FindMax( int a[], int left, int right )
{
int middle;
int max_l, max_r;
if ( left == right )
{
// osnovniot slucaj

// samo 1 element

return a[left];
}
else
{
// Resavanje na pomali problemi
middle = (left+right)/2;

// Deleneje na dva dela

max_l = FindMax( a, left, middle);

// najdi go mx vo prvata polovina
max_r = FindMax( a, middle+1, right);
// Najdi go max vo vtorata polovina
// Use the solutions to solve original problem
if ( max_l > max_r )
return(max_l);
else
return(max_r);
}
}

.
static int MaxEl(Node p) {
int max,maxLevo,maxDesno;
if(p!=null){
max=p.data;
maxLevo=MaxEl(p.left);
maxDesno=MaxEl(p.right);
if (max<maxLevo) max=maxLevo;
if (max<maxDesno) max=maxDesno;
return max;

}
}

:
T(n) = 2T(n/2) + n
2T(n/2) = 2(2(T(n/4)) + n/2) = 4T(n/4) + n T(n) = 4T(n/4) + 2n
4T(n/4) = 4(2T(n/8)) + (n/4) = 8T(n/8) + n T(n) = 8T(n/8) + 3n ...
T (n) 2k T (n 2k ) kn k = log2 n, :
n
1
log2 2
2k
T (n) n T (1) n log2 n
k log n
T(n) = nT(1) + n log2 n = n log2 n + n
2logb n

n logb 2

T (n)

cn log n n

O(n log 2 n)

n c,

2 d AVL
.
depth(d) d.
: AVL .
1.
AVL
.
static int avl(Node d){
int L,D;
if (d=null) return 1;
if (abs(height (d.left)- height (d.right))>1) return 0;
L= avl(d.left);
D= avl(d.right);
return L&&D;
}

3 x
.
: false.
, ,
.
static int Najdi(Node d, int X){
if (d==null) return 0;
else
if(d.data==X) return 1;
else return (Najdi(d.left,X)|| Najdi(d.right,X));
}

11.2

( ) .
,
. ,
. . ,
, ,
.
, (greedy,
). (
,
, ),
.


. , 269 ,
,
. ,
100 , 50 , 10, 5
. (
)
.
4
. .
1,2,5,10,50,100,500 .
public class Change {
private int[] denom;
private String name;
Change(String name, int[] denom) {
this.name = name;
this.denom = denom;
}
void giveChange(int changeInCent) {
System.out.println("\nChange for " + changeInCent + " in " +
name + ":");
for(int i = 0; i < denom.length; ++i) {
int nb = changeInCent / denom[i];
if(nb > 0)
System.out.println(nb + " " + denom[i]);
changeInCent %= denom[i];
}
}
public static void main(String[] args) {
int[] mk = {100, 50, 10, 5, 2, 1};
int[] us = {100, 25, 10, 5, 1};

// MK
// US

Change change1 = new Change("MK", mk);

Change change2 = new Change("USA", us);
change1.giveChange(456734);



change2.giveChange(456734);
change1.giveChange(12345);
change2.giveChange(12345);
}
}

T(n)=O(n), ,
GreedyCoins n .
5 ( ) .
.
, 2/3=1/2+1/6 7/13=1/2 + 1/26.
,
, .

11.3

, .
,
.

.
:
public static int fibonacci(int n){
if(n <= 1) return 1;
else
return(fibonacci(n-1) + fibonacci(n-2));
}

T(n) = T(n - 1) + T(n - 2) + 2 = O(2n)

,
.
1. DP .
public static int fibonacci(int n){
int fib_pret=1;
int fib_pret_pret=1;
for (int j=1;j<n;j++){
int fib_nov = fib_pret + fib_pret_pret;
fib_pret_pret = fib_pret;
fib_pret = fib_nov;
}
return fib_pret;
}

T(n)=O(n).
2. Memoization
.
public class Fibonacci
{
int []memo= {0,1}
public static int fibMem ( int n )
{
if ( n < 1 ) return 0; // Allows memo[k]==0 to flag uncomputed cell
if ( n >= memo.length )
{
int[] omem = new Int[n+1];
System.arraycopy(memo, 0, omem, 0, memo.length);
memo = omem;
}
if ( memo[n] == 0 )
memo[n] = fibMem(n-2) + fibMem(n-1);
return memo[n];
}

11.4

BACKTRACKING

Backtracking brute
force , .
(v1, ..., vm)

. .
.
(v1, ..., vi) ,

.

6
, .
.

public class Permute

{
static void swap(Object[] x, int j, int k)
{ Object temp = x[j]; x[j] = x[k]; x[k] = temp;

static void permute(Object[] x, int idx)

{ int k;
if (idx == x.length)
{
for (k = 0; k < x.length; k++)
System.out.print(x[k]);
System.out.println();
}
else
{ Object hold;
for (k = idx; k < x.length; k++)
{ swap (x, idx, k);
permute(x, idx+1);
}
hold = x[idx]; // Belongs at the very end.
for (k = idx+1; k < x.length; k++)
x[k-1] = x[k];
x[k-1] = hold;
}
}
public static void main(String[] args)
{
Integer[] vect = { 1, 2, 3, 4 };
permute(vect, 0);
}
}

permute i=N-1, , i=N-2 21 ,

i=N-3 321 ,..., i=1 (N-1)...321=(N-1)! , i=0
N! . T(n)=nT(n-1)=O(n!).