Today’s Material

• Long Integer Multiplication

– Iterative Algorithm
– Divide & Conquer Algorithm

1
 Problem Definition
• Given two decimal numbers consisting of “N”
digits, design an algorithm to multiply them
efficiently

• What’s the maximum signed integer you can

represent in a 4 or 8 byte integer?
– 231 – 1 = 2147483647
– 263 – 1 = 9223372036854775807

• What if you want to work with very large

numbers
– Assume N = 100, 500 or 1000
2
 Applications
• Cryptography
– Techniques for encryption/decryption are based on
number-theoretic techniques that use very large
numbers

– DES uses 56-bit keys

– RSA uses 1024 bit keys

– Bottom line is, we need efficient algorithms to

manipulate large numbers

3
 Representing Long Integers
• You can simply use an array
– Each slot of the array keeps one digit of the number
– A[0] stores the least significant digit
– A[N-1] stores the most-significant digit

• Example:
– char A[] = {4, 1, 5, 3, 2}; // 23514
– char B[] = {9, 5, 2, 1}; // 1259

4
 Operations on Long Integers
• Addition and subtraction is easy
– Simply add/subtract digit by digit – O(N)

• What about multiplication?

– Basic multiplication works digit-by-digit
– How much does this take? O(N2)

– Can we make this faster? How about a divide &

conquer strategy?

5
 D&Q Long Integer Multiplication
n
n/2 n/2

w x A

y z B

wz xz

wy xy

wy wz + xz xz P=A*B

• Think of A and B consisting of two superdigits

of size roughly n/2 digits

6
 D&Q Long Integer Multiplication
n
n/2 n/2

w x A

y z B

• Let m = n/2
• A = w*10m + x
• B = y*10m + z

• Mult(A, B) = Mult(w, y)*102m + (Mult(w, z) + Mult(x, y))*10m + Mult(x, z)

• Multiplying by 10m can be though of shifting the number by

m digits to the right. So it is not really a multiplication
7
D&Q Long Integer Multiplication
void Mult(char A[], char B[], char P[], int N){
if (N == 1){..; return; } // Base case

w = most significant n/2 digits of A;

x = least significant n/2 digits of A;
y = most significant n/2 digits of B;
z = most significant n/2 digits of B;

Mult(w, y, C, N/2); Shift C 2m digits to the right;

Mult(w, z, D, N/2); Shift D m digits to the right;
Mult(x, y, E, N/2); Shift E m digits to the right;
Mult(x, z, F, N/2);
P = C + D + E + F;
} //end-Mult

1 if n =1 (Base case)
T(n) = T(n) = (n2)
4*T(n/2) + n if n>1
 Faster Long Integer Multiplication
n
n/2 n/2

w x A

y z B

• Let m = n/2, A = w*10m + x, B = y*10m + z

• C = Mult(w, y)
• D = Mult(x, z)
• E = Mult((w+x), (y+z)) - C - D;
• Product = C*102m + E*10m + D;

• Notice that we only have 3 multiplications here!

9
D&Q Long Integer Multiplication
void Mult(char A[], char B[], char P[], int N){
if (N == 1){..; return; } // Base case

w = most significant n/2 digits of A;

x = least significant n/2 digits of A;
y = most significant n/2 digits of B;
z = most significant n/2 digits of B;

Mult(w, y, C, N/2);
Mult(x, z, D, N/2);
Mult(w+x, y+z, E, N/2);
E -= C – D;
P = C*102m + E*10m + D;
} //end-Mult

1 if n =1 (Base case)
T(n) = T(n) = (n1.585)
3*T(n/2) + n if n>1
Summary of Long Int Multiplication
• Brute-force iterative algorithm = (n2)
• Divide & Conquer algorithm = (n1.585)

• But D&Q algorithm has a larger constant factor

hidden inside the asymptotic notation
– If we assume that D&Q algorithm’s overhead is 5
times more than the iterative algorithm, then D&Q
will be better for n2 >= 5*n1.585  n >= 50

– If the overhead is 10 times more, then D&Q will be

better for n >= 260

11