Constructing

the

Spanners

of

Graphs

in

Parallel

Weifa

Liang

and

Richard

P.

Brent

January

Joint

Computer

Science

Technical

Report

Series

Department

of

Computer

Science

Faculty

of

Engineering

and

Information

Technology

Computer

Sciences

Laboratory

Research

School

of

Information

Sciences

and

Engineering

This

technical

report

series

is

published

jointly

by

the

Department

of

Computer

Science

Faculty

of

Engineering

and

Information

Technology

and

the

Computer

Sciences

Laboratory

Research

School

of

Information

Sciences

and

Engineering

The

Australian

National

University

Please

direct

correspondence

regarding

this

series

to

Technical

Reports

Department

of

Computer

Science

Faculty

of

Engineering

and

Information

Technology

The

Australian

National

University

Canberra

ACT

Australia

or

send

email

to

Technical.Reports@cs.anu.edu.au

A

list

of

technical

reports

including

some

abstracts

and

copies

of

some

full

reports

may

be

found

at

Recent

reports

in

this

series

David

Hawking

The

design

and

implementation

of

a

parallel

document

retrieval

engine

December

Raymond

H.

Chan

and

Michael

K.

Ng

Conjugate

gradient

methods

for

Toeplitz

systems

September

Oscar

Bosman

and

Heinz

W.

Schmidt

Object

test

coverage

using

nite

state

machines

September

Jeffrey

X.

Yu

Kian-Lee

Tan

and

Xun

Qu

On

balancing

workload

in

a

highly

mobile

environment

August

Department

of

Computer

Science

Annual

report

August

Douglas

R.

Sweet

and

Richard

P.

Brent

Error

analysis

of

a

partial

pivoting

method

for

structured

matrices

June

Constructing

the

Spanners

of

Graphs

in

Weifa

Liangy

Richard

P.

Brentz

y

Department

of

Computer

Science

The

Australian

National

University

Canberra

ACT

Australia

wliang@cs.anu.edu.au

z

Computer

Sciences

Lab

The

Australian

National

University

Canberra

ACT

Australia

rpb@discus.anu.edu.au

Abstract

Given

a

connected

graph

G

-LRB-

V

E

-RRB-

with

n

vertices

and

m

edges

the

distance

between

two

vertices

in

G

is

the

weight

of

the

shortest

path

between

them

A

subgraph

is

a

t-spanner

-LRB-

an

approximate

t-spanner

-RRB-

of

G

if

for

every

u

v

V

the

distance

between

u

and

v

in

is

at

most

t

-LRB-

f

-LRB-

t

-RRB-

-RRB-

times

longer

than

the

distance

in

G

where

f

-LRB-

t

-RRB-

is

a

polynomial

function

of

variable

t

and

t

f

-LRB-

t

-RRB-

n

In

this

paper

parallel

algorithms

for

finding

approximate

t-spanners

on

both

unweighted

graphs

and

weighted

graphs

are

given

If

G

is

an

unweighted

graph

our

algorithm

requires

O

-LRB-

ntk

log

n

-RRB-

time

and

M

-LRB-

n

-RRB-

processors

and

the

spanner

generated

has

size

of

O

-LRB-

-LRB-

ntk

-RRB-

t

n

-RRB-

and

factor

of

O

-LRB-

tk

-RRB-

otherwise

our

algorithm

requires

O

-LRB-

-LRB-

ntk

-RRB-

-LRB-

ntk

-RRB-

-LRB-

t

-RRB-

log

n

-RRB-

time

and

O

-LRB-

-RRB-

processors

and

the

spanner

generated

has

size

of

O

-LRB-

-LRB-

ntk

-RRB-

-LRB-

t

-RRB-

n

-RRB-

weight

of

-LRB-

-LRB-

ntk

-RRB-

ffl

t

-RRB-

wt

-LRB-

MST

-RRB-

and

factor

of

O

-LRB-

Dtk

-RRB-

where

M

-LRB-

n

-RRB-

is

the

number

of

processors

needed

to

find

a

Breadth-First

Search

tree

in

a

graph

with

n

vertices

in

time

O

-LRB-

log

n

-RRB-

D

is

the

maximum

edge

weight

of

a

minimum

spanning

tree

of

G

and

k

is

a

fixed

constant

integer

with

k

logt

n.

Also

an

NC

algorithm

for

finding

a

on

a

weighted

graph

G

with

size

O

-LRB-

minfm

t

ffl

-LRB-

Wmax

Wmin

-RRB-

g

-RRB-

is

presented

The

proposed

algorithm

requires

O

-LRB-

n

ffl

-LRB-

Wmax

Wmin

-RRB-

-RRB-

time

and

O

-LRB-

-RRB-

processors

where

Wmax

maxfwt

-LRB-

e

-RRB-

j

e

Eg

Wmin

minfwt

-LRB-

e

-RRB-

j

e

Eg

and

ffl

is

a

constant

with

ffl

All

algorithms

are

for

a

CRCWPRAM

model

short

version

will

appear

in

Proc

of

Intern

Conf

on

Parallel

Processing

Sympo.

Introduction

Given

a

connected

graph

G

-LRB-

V

E

-RRB-

with

n

vertices

and

m

edges

a

subgraph

is

a

t-spanner

-LRB-

an

approximate

t-spanner

-RRB-

of

G

if

for

every

u

v

V

the

distance

between

u

and

v

in

is

at

most

t

-LRB-

f

-LRB-

t

-RRB-

-RRB-

times

longer

than

the

distance

in

G

where

f

-LRB-

t

-RRB-

is

a

polynomial

function

of

variable

t

and

t

f

-LRB-

t

-RRB-

n

The

value

of

t

and

f

-LRB-

t

-RRB-

are

called

the

factors

of

G

There

are

two

criteria

to

measure

the

sparseness

of

a

spanner

that

is

the

size

defined

as

the

number

of

edges

in

the

spanner

and

the

weight

defined

as

the

sum

of

the

edge

weights

in

the

spanner

The

minimum

spanning

tree

-LRB-

MST

-RRB-

of

G

is

obviously

the

sparsest

spanner

in

terms

of

both

size

and

weight

but

its

factor

can

be

as

bad

as

n

-LSB-

-RSB-

For

convenience

we

denote

by

wt

-LRB-

MST

-RRB-

the

sum

of

the

edge

weight

of

the

MST

Usually

the

sparseness

of

a

spanner

is

judged

by

comparing

it

to

the

size

and

the

weight

of

the

MST

Regarding

the

spanners

on

some

special

graphs

such

as

Euclidean

graphs

geometry

graphs

and

chordal

graphs

much

effort

has

been

taken

in

recent

several

works

-LSB-

-RSB-

Peleg

and

Sch

-RCB-

affer

-LSB-

-RSB-

Alth

-RCB-

ofer

Das

Dobkin

Joseph

and

Soares

-LSB-

-RSB-

have

shown

some

very

interesting

characters

about

the

t-spanner

of

both

unweighted

graphs

and

weighted

graphs

Besides

the

spanner

concept

has

a

number

of

applications

For

example

the

sparse

spanner

of

unweighted

graphs

is

used

in

distributed

computing

and

communication

network

design

-LSB-

-RSB-

Peleg

and

Upfal

-LSB-

-RSB-

Awerbuch

Bar-Noy

Linial

and

Peleg

-LSB-

-RSB-

and

Awerbuch

and

Peleg

-LSB-

-RSB-

use

it

to

design

efficient

routing

schemes

in

distributed

networks

Peleg

and

Ullman

-LSB-

-RSB-

also

point

out

that

the

t-spanner

is

useful

to

design

a

synchronizer

-LSB-

-RSB-

Whereas

Cohen

-LSB-

-RSB-

suggests

a

randomized

parallel

algorithm

for

finding

a

t-spanner

with

size

O

-LRB-

fflt

-RRB-

on

a

weighted

graph

which

needs

O

-LRB-

Wmax

Wmin

n

-RRB-

expected

time

with

O

-LRB-

fimfi

n

-RRB-

work

on

an

EREW

PRAM

where

t

-LRB-

ffl

-RRB-

where

wt

-LRB-

e

-RRB-

is

the

weight

of

edge

e

Wmax

maxfwt

-LRB-

e

-RRB-

j

e

Eg

Wmin

minfwt

-LRB-

e

-RRB-

j

e

Eg

and

ffl

is

an

arbitrarily

small

constant

Despite

existing

several

efficient

sequential

and

distributed

algorithms

for

finding

a

sparse

t-spanner

of

graphs

we

have

not

seen

any

deterministic

parallel

algorithm

for

this

problem

In

this

paper

we

first

relax

the

restriction

of

the

problem

by

introducing

approximate

t-spanner

concept

and

then

present

simple

parallel

algorithms

for

finding

a

sparse

approximate

t-spanner

on

both

unweighted

graphs

and

weighted

graphs

in

terms

of

both

size

and

weight

The

algorithms

exhibit

a

trade-off

between

the

running

time

and

the

factor

of

the

spanner

Finally

we

present

an

NC

algorithm

for

finding

a

on

a

weighted

graph

G

The

remaining

parts

of

this

paper

are

organized

as

follows

In

Section

we

introduce

some

notations

and

the

tree

decomposition

concept

The

algorithms

for

finding

an

approximate

t-spanner

for

both

unweighted

graphs

and

weighted

graphs

with

factors

O

-LRB-

tk

-RRB-

and

O

-LRB-

Dtk

-RRB-

are

presented

in

Section

where

D

maxfwt

-LRB-

e

-RRB-

je

MSTg

If

G

is

an

unweighted

graph

the

algorithm

requires

O

-LRB-

n

tk

log

n

-RRB-

time

and

M

-LRB-

n

-RRB-

processors

where

M

-LRB-

n

-RRB-

is

the

number

of

processors

needed

to

find

a

BreadthFirst

Search

tree

in

a

graph

with

n

vertices

in

time

O

-LRB-

log

n

-RRB-

The

approximate

t

spanner

delivered

by

this

algorithm

has

size

of

O

-LRB-

-LRB-

n

tk

-RRB-

t

n

-RRB-

Otherwise

the

algo

rithm

requires

O

-LRB-

-LRB-

n

tk

-RRB-

-LRB-

n

tk

-RRB-

-LRB-

t

-RRB-

log

n

-RRB-

time

and

O

-LRB-

-RRB-

processors

The

approx

imate

t-spanner

delivered

by

this

algorithm

has

size

of

O

-LRB-

-LRB-

n

tk

-RRB-

-LRB-

t

-RRB-

n

-RRB-

weight

of

-LRB-

-LRB-

n

tk

-RRB-

ffl

t

-RRB-

wt

-LRB-

MST

-RRB-

In

Section

we

suggest

an

NC

algorithm

for

constructing

a

on

a

weighted

graph

G

with

size

O

-LRB-

minfm

t

ffl

-LRB-

Wmax

Wmin

-RRB-

g

-RRB-

This

algorithm

requires

O

-LRB-

n

ffl

-LRB-

Wmax

Wmin

-RRB-

-RRB-

time

and

O

-LRB-

-RRB-

processors

where

ffl

is

a

small

constant

with

ffl

We

conclude

in

Section

by

leaving

an

open

problem

All

proposed

parallel

algorithms

run

on

a

CRCW

PRAM

in

which

simultaneous

access

by

more

than

one

processor

to

the

same

memory

location

for

both

read

and

write

is

allowed

In

case

several

processors

attempt

to

write

in

the

same

memory

location

simultaneously

an

arbitrary

one

succeeds

in

doing

the

write

Preliminaries

Notations

Let

Xi

V

and

-LSB-

si

V

i

s

n

The

set

H

fXi

j

i

sg

is

called

the

coarse

vertex

cover

on

V

if

there

exists

Xi

and

Xj

such

that

Xi

Xj

O

i

j.

Otherwise

H

is

called

the

exact

vertex

cover

on

V

If

H

is

an

exact

vertex

cover

on

V

then

X

H

is

called

a

vertex

cluster

Otherwise

X

is

simply

called

a

partial

cover

For

a

vertex

u

X

is

called

u

's

home

cover

if

u

X

Obviously

for

an

exact

vertex

cover

H

every

vertex

u

V

has

only

one

home

cover

An

inverted

tree

is

a

directed

tree

with

the

edges

directed

towards

the

root

and

the

root

has

a

directed

self-loop

Tree

decomposition

In

order

to

make

our

algorithmic

description

easier

in

section

we

first

introduce

a

restricted

tree

decomposition

concept

Let

T

-LRB-

V

ET

-RRB-

be

an

inverted

tree

with

n

vertices

we

define

the

following

restricted

decomposition

as

the

tree

decomposition

in

which

each

inverted

tree

T

is

divided

into

a

forest

of

inverted

subtrees

and

every

subtree

has

no

more

than

two

levels

-LRB-

the

root

of

a

tree

is

defined

as

the

first

level

-RRB-

where

bn

The

tree

decomposition

defined

above

can

be

easily

implemented

in

parallel

We

calculate

the

level

number

for

every

vertex

in

T

After

that

the

vertex

set

V

is

divided

into

two

disjoint

subsets

consisting

of

all

vertices

with

odd

level

numbers

and

consisting

of

all

vertices

with

even

level

numbers

If

then

all

vertices

in

are

selected

as

the

roots

of

subtrees

Let

u

be

such

a

vertex

a

vertex

v

belongs

to

the

subtree

rooted

at

u

if

and

only

if

the

level

number

of

v

is

larger

than

that

of

u

by

one

and

u

is

the

parent

of

v

in

T

Otherwise

we

select

the

vertices

in

as

the

roots

of

these

subtrees

For

this

case

we

assign

the

root

r

of

T

to

one

of

the

subtrees

in

which

the

root

is

one

of

r

's

children

in

T

Lemma

Let

F

be

a

forest

in

which

the

number

of

vertices

is

n

and

each

tree

has

two

vertices

at

least

Then

implementing

all

tree

decompositions

in

F

can

be

finished

in

O

-LRB-

log

n

-RRB-

time

using

O

-LRB-

n

-RRB-

processors

Proof

For

every

tree

T

in

F

we

first

calculate

its

vertex

level

numbers

and

jVij

i

All

of

these

operations

can

be

done

in

O

-LRB-

log

n

-RRB-

time

with

O

-LRB-

n

-RRB-

processors

Then

for

every

tree

with

we

apply

the

tree

decomposition

on

it

which

can

be

done

in

O

-LRB-

-RRB-

time

with

O

-LRB-

n

-RRB-

processors

Finally

we

apply

the

tree

decomposition

to

those

trees

with

Therefore

the

restricted

tree

decomposition

in

F

can

be

finished

in

O

-LRB-

log

n

-RRB-

time

with

O

-LRB-

n

-RRB-

processors

Parallel

Algorithms

for

Finding

Approximate

t-Spanners

Unweighted

Graphs

The

algorithm

for

finding

a

Peleg

and

Sch

-RCB-

affer

-LSB-

-RSB-

once

gave

the

following

lemma

and

proved

that

the

size

of

the

spanner

is

tight

in

big-O

sense

Lemma

-LSB-

-RSB-

For

every

n-vertex

graph

G

and

for

every

fixed

t

there

exists

a

polynomial

time

constructible

-LRB-

-RRB-

spanner

with

O

-LRB-

t

-RRB-

edges

Actually

Lemma

is

derived

directly

from

Awerbuch

's

algorithm

of

constructing

an

optimal

synchronizer

-LSB-

-RSB-

In

the

following

we

show

that

a

with

size

O

-LRB-

t

-RRB-

can

be

achieved

by

the

algorithm

of

Awerbuch

The

basic

idea

of

his

algorithm

is

described

as

follows

The

vertex

set

V

is

partitioned

into

maximum

subsets

of

vertices

called

clusters

such

that

every

cluster

is

connected

and

the

diameter

of

every

cluster

does

not

exceed

the

logarithm

of

its

cardinality

This

guarantees

that

the

total

number

of

the

neighboring

cluster

pairs

is

linear

and

the

maximum

cluster

diameter

is

logarithmic

in

the

number

of

the

graph

's

vertices

In

the

following

the

remaining

graph

denotes

the

subgraph

induced

by

the

vertices

that

were

not

yet

joined

to

clusters

The

basic

phase

of

his

algorithm

is

that

a

vertex

in

the

remaining

graph

is

chosen

as

the

new

cluster

center

and

a

cluster

centered

at

this

vertex

is

formed

This

phase

is

repeated

until

there

are

no

more

vertices

in

the

remaining

graph

In

details

let

p

t

first

select

an

arbitrary

vertex

v

as

the

root

of

a

Breath-First

Search

-LRB-

BFS

-RRB-

tree

and

then

generate

this

BFS

tree

level

by

level

until

it

reaches

some

level

such

that

the

number

of

vertices

in

this

level

is

less

than

p

times

the

total

number

of

vertices

in

all

previous

levels

and

the

level

is

said

the

rejected

level

At

that

moment

the

procedure

for

generating

clusters

is

terminated

and

all

vertices

with

level

number

l

belong

to

the

cluster

Cv

centered

at

v

After

a

cluster

C

formed

its

rejected

level

is

examined

If

it

is

not

empty

then

a

vertex

u

in

this

rejected

level

is

chosen

as

the

new

cluster

center

In

case

the

rejected

level

of

cluster

C

is

empty

the

algorithm

backtracks

to

the

cluster

from

which

C

itself

is

found

The

resulting

spanner

SP

-LRB-

G

-RRB-

-LRB-

V

-LSB-

-RRB-

of

G

is

constructed

as

follows

-LSB-

all

clusters

Cfe

e

is

an

edge

in

the

BFS

tree

of

a

cluster

Cg

and

f

-LRB-

u

v

-RRB-

-LRB-

u

v

-RRB-

E

u

Cu

and

v

Cvg

So

the

size

of

this

spanner

is

-LRB-

n

-RRB-

pn

O

-LRB-

t

-RRB-

We

leave

the

analysis

of

the

factor

of

this

spanner

later

The

parallelization

of

Awerbuch

's

algorithm

is

not

very

difficult

Here

we

give

a

parallel

version

of

his

algorithm

Algorithm

Step

Initialization

A

-LRB-

i

-RRB-

B

-LRB-

i

-RRB-

count

A

-LRB-

i

-RRB-

means

vertex

i

does

not

belong

to

any

clusters

yet

B

-LRB-

i

-RRB-

means

vertex

i

is

explored

by

the

B

-LRB-

i

-RRB-

th

cluster

count

is

the

number

of

clusters

in

G

Step

while

there

exists

a

vertex

i

with

A

-LRB-

i

-RRB-

do

Step

count

count

select

a

vertex

i

with

A

-LRB-

i

-RRB-

and

B

-LRB-

i

-RRB-

maxfB

-LRB-

j

-RRB-

j

ng

as

the

root

of

of

the

new

BFS

tree

set

A

-LRB-

i

-RRB-

and

B

-LRB-

i

-RRB-

count

Step

Generate

a

BFS

subtree

Ti

rooted

at

i

such

that

the

diameter

of

Ti

does

n't

exceed

the

logarithm

of

its

cardinality

Step

for

every

vertex

v

in

Ti

set

A

-LRB-

v

-RRB-

Step

for

every

vertex

v

in

the

rejected

level

of

Ti

set

B

-LRB-

v

-RRB-

count

endwhile

Now

we

have

the

following

lemma

Lemma

Let

G

-LRB-

V

E

-RRB-

be

an

unweighted

connected

graph

Then

a

of

G

with

size

O

-LRB-

t

-RRB-

can

be

generated

in

O

-LRB-

n

log

n

-RRB-

time

with

M

-LRB-

n

-RRB-

processors

Proof

By

Algorithm

the

initialization

can

be

done

in

O

-LRB-

-RRB-

time

using

O

-LRB-

n

-RRB-

processors

Then

generating

a

cluster

and

labeling

this

cluster

can

be

done

in

O

-LRB-

log

n

-RRB-

time

with

M

-LRB-

n

-RRB-

processors

Note

that

M

-LRB-

n

-RRB-

-LRB-

-RRB-

currently

the

best

result

of

M

-LRB-

n

-RRB-

-LSB-

-RSB-

Finally

selecting

the

center

for

the

new

cluster

needs

O

-LRB-

log

n

-RRB-

time

and

O

-LRB-

n

log

n

-RRB-

processors

by

prefix

computation

While

the

number

of

iterations

of

the

while

loop

is

at

most

O

-LRB-

n

-RRB-

Obviously

the

total

number

of

edges

in

all

BFS

trees

is

at

most

n

By

the

definition

for

a

cluster

with

vertices

there

are

at

most

edges

connected

with

other

clusters

Therefore

the

resulting

spanner

has

O

-LRB-

pn

-RRB-

O

-LRB-

t

-RRB-

edges

The

factor

of

this

spanner

is

considered

as

follows

For

an

edge

-LRB-

u

v

-RRB-

E

not

in

if

u

and

v

are

in

the

some

cluster

centered

at

w

Cw

then

the

distance

between

u

and

v

is

at

most

the

distance

between

u

and

w

plus

the

distance

between

v

and

w.

So

the

distance

between

u

and

v

is

no

more

than

logp

n

In

case

u

Cu

and

v

Cv

then

the

distance

between

u

and

v

is

one

and

-LRB-

u

v

-RRB-

by

the

algorithm

The

algorithm

for

finding

an

approximate

t-spanner

Our

algorithm

consists

of

several

phases

The

basic

idea

behind

our

algorithm

is

that

in

each

phase

we

compress

those

vertices

whose

distances

are

not

far

away

from

each

other

into

a

supervertex

-LRB-

also

called

a

cluster

-RRB-

form

a

supergraph

G

-LRB-

V

E

-RRB-

where

V

consists

of

all

supervertices

and

there

is

an

edge

in

E

if

and

only

if

there

is

at

least

one

edge

in

G

between

two

supervertices

-LRB-

we

keep

track

of

its

corresponding

edge

in

G

-RRB-

So

the

approximate

spanner

denote

by

SP

-LRB-

G

-RRB-

of

G

can

be

expressed

as

SP

-LRB-

G

-RRB-

-LSB-

fthe

tree

edges

in

clustersg

recursively

In

the

following

we

give

the

detailed

algorithm

The

function

D

on

V

defines

a

forest

of

inverted

trees

in

which

D

-LRB-

v

-RRB-

is

the

parent

of

v.

Algorithm

i

V

V

while

i

k

do

for

j

to

tc

do

Step

for

each

vertex

v

in

V

set

D

-LRB-

v

-RRB-

v

Step

for

each

vertex

v

find

an

neighbor

u

with

the

smallest

index

and

set

D

-LRB-

v

-RRB-

u

if

D

-LRB-

D

-LRB-

v

-RRB-

-RRB-

v

and

D

-LRB-

v

-RRB-

v

then

if

D

-LRB-

v

-RRB-

v

then

D

-LRB-

v

-RRB-

v

else

D

-LRB-

D

-LRB-

v

-RRB-

-RRB-

D

-LRB-

v

-RRB-

As

a

result

we

obtain

a

forest

F

of

inverted

trees

Now

there

is

a

forest

F

containing

all

inverted

trees

formed

in

Step

and

each

inverted

tree

has

at

least

two

vertices

Step

generate

another

forest

F

by

applying

the

tree

decomposition

to

F

Denote

by

Ei

j

the

edge

set

in

F

Now

every

tree

is

partitioned

into

many

inverted

subtrees

Step

Construct

a

supergraph

G

-LRB-

V

E

-RRB-

such

that

each

inverted

subtree

in

F

is

a

supervertex

and

there

is

an

edge

in

E

if

there

is

an

edge

between

two

vertices

in

these

two

supervertices

endfor

i

i

endwhile

Step

Find

a

of

the

resulting

supergraph

G

-LRB-

V

E

-RRB-

in

parallel

by

applying

the

parallel

algorithm

in

Section

Step

The

approximate

t-spanner

SP

-LRB-

G

-RRB-

of

G

is

G

-LRB-

V

-LSB-

j

tc

i

k

Ei

j

-RRB-

-LSB-

Theorem

Given

an

unweighted

connected

graph

G

-LRB-

V

E

-RRB-

an

approximate

tspanner

with

factor

O

-LRB-

tk

-RRB-

can

be

constructed

in

O

-LRB-

n

tk

log

n

-RRB-

time

using

M

-LRB-

n

-RRB-

processors

Proof

By

the

proposed

algorithm

above

we

know

that

the

Step

-LCB-

Step

can

be

finished

in

O

-LRB-

k

t

log

n

-RRB-

time

using

at

most

O

-LRB-

m

n

-RRB-

processors

The

Step

can

be

done

in

O

-LRB-

n

tk

log

n

-RRB-

time

using

M

-LRB-

n

-RRB-

processors

by

Lemma

and

this

step

is

also

the

dominant

step

of

the

proposed

algorithm

Theorem

The

approximate

t-spanner

generated

by

Algorithm

has

size

of

O

-LRB-

-LRB-

n

tk

-RRB-

t

n

-RRB-

and

the

factor

of

O

-LRB-

tk

-RRB-

where

k

is

a

fixed

constant

k

c

logt

n

and

c

Proof

By

Lemma

we

know

that

the

number

of

supervertices

in

a

supergraph

is

at

most

half

of

the

number

of

vertices

of

its

immediately

precedent

supergraph

assuming

G

is

an

initial

supergraph

Let

the

number

of

supervertices

of

current

supergraph

be

ni

-LRB-

n

-RRB-

Then

the

number

of

supervertices

of

the

resulting

supergraph

after

finishing

the

for

loop

is

at

most

O

-LRB-

nit

-RRB-

Therefore

the

final

supergraph

has

O

-LRB-

n

tk

-RRB-

supervertices

after

finishing

the

while

loop

Following

Lemma

the

of

the

final

supergraph

has

size

O

-LRB-

-LRB-

n

tk

-RRB-

t

-RRB-

We

also

note

that

for

fixed

i

jEi

j

j

jEi

j

and

n

because

each

Ei

j

is

the

edge

set

of

a

forest

of

inverted

trees

So

tc

j

jEi

j

j

O

-LRB-

nti

-RRB-

Therefore

the

size

of

the

resulting

approximate

spanner

is

O

-LRB-

-LRB-

n

tk

-RRB-

t

n

-RRB-

Now

we

calculate

the

factor

Let

dl

be

the

maximum

diameter

of

a

cluster

in

the

lth

iteration

of

variable

j

for

fixed

i

in

the

algorithm

above

Initially

every

vertex

in

G

is

a

supervertex

and

the

diameter

of

every

supervertex

is

-LRB-

-RRB-

when

i

The

equation

is

described

as

follows

dl

l

tc

From

the

equation

above

we

derive

that

tc

t

Therefore

the

maximum

distance

between

two

adjacent

vertices

in

G

belonging

to

the

same

supervertex

is

at

most

O

-LRB-

tk

-RRB-

and

the

factor

of

the

resulting

spanner

is

O

-LRB-

-LRB-

-RRB-

-RRB-

O

-LRB-

tk

-RRB-

where

is

a

constant

Corollary

Given

a

connected

unweighted

graph

G

-LRB-

V

E

-RRB-

a

-LRB-

-RRB-

spanner

with

size

O

-LRB-

minfm

-LRB-

nt

-RRB-

-RRB-

can

be

generated

in

O

-LRB-

log

n

-RRB-

time

using

O

-LRB-

m

n

-RRB-

processors

Proof

By

setting

k

run

the

Step

-LCB-

Step

of

Algorithm

we

get

a

supergraph

G

-LRB-

V

E

-RRB-

Having

this

supergraph

a

-LRB-

-RRB-

spanner

G

-LRB-

V

-LSB-

-RRB-

of

G

is

constructed

as

follows

-LSB-

tc

j

j

and

only

one

edge

-LRB-

-RRB-

is

selected

into

for

all

edges

-LRB-

x

y

-RRB-

E

x

y

and

vi

V

for

i

So

the

size

of

the

resulting

spanner

is

-LRB-

nt

-RRB-

O

-LRB-

minfm

-LRB-

nt

-RRB-

-RRB-

The

factor

of

this

spanner

is

analyzed

as

follows

Consider

an

edge

-LRB-

x

y

-RRB-

E

but

-LRB-

x

y

-RRB-

-LSB-

If

x

y

v

V

then

the

distance

between

them

in

the

spanner

is

at

most

Otherwise

let

x

and

y

and

the

edge

between

and

be

-LRB-

-RRB-

then

the

distance

between

x

and

y

in

the

spanner

is

the

summation

of

the

distance

between

x

and

plus

the

distance

between

y

and

and

plus

one

-LRB-

the

edge

-LRB-

-RRB-

-RRB-

which

equals

at

most

Weighted

Graphs

The

algorithm

for

finding

a

t-spanner

Alth

-RCB-

ofer

Das

Dobkin

Joseph

and

Soares

-LSB-

-RSB-

first

consider

the

problem

of

finding

a

sparse

t-spanner

-LRB-

V

-RRB-

in

an

non-negative

weighted

graph

G

-LRB-

V

E

-RRB-

and

present

a

simple

greedy

algorithm

for

this

problem

described

as

follows

Let

dG

-LRB-

x

y

-RRB-

be

the

weight

of

the

shortest

path

between

vertices

x

and

y

in

graph

G.

Algorithm

Step

Initialization

Step

Sort

E

by

non-decreasing

weight

Step

-LRB-

V

O

-RRB-

Step

for

every

edge

e

-LRB-

u

v

-RRB-

in

E

-LRB-

from

the

sorted

list

-RRB-

do

Step

Compute

P

-LRB-

u

v

-RRB-

the

shortest

path

between

u

and

v

in

Step

if

-LRB-

u

v

-RRB-

t

dG

-LRB-

u

v

-RRB-

then

-LSB-

f

-LRB-

u

v

-RRB-

g

-LRB-

V

-RRB-

endfor

Step

Output

If

we

use

the

fastest

algorithm

for

finding

the

shortest

path

between

two

vertices

-LSB-

-RSB-

Algorithm

can

be

implemented

in

O

-LRB-

mm

mn

log

n

-RRB-

O

-LRB-

-RRB-

time

The

size

of

is

O

-LRB-

-LRB-

t

-RRB-

-RRB-

and

the

weight

is

less

than

-LRB-

n

t

-RRB-

wt

-LRB-

MST

-RRB-

-LSB-

-RSB-

By

a

considerably

improved

analysis

of

this

algorithm

Chandra

Das

Narasimhan

and

Soares

-LSB-

-RSB-

show

that

the

running

time

of

this

algorithm

is

O

-LRB-

-LRB-

t

-RRB-

-RRB-

and

the

weight

of

is

no

more

than

O

-LRB-

n

ffl

t

wt

-LRB-

MST

-RRB-

-RRB-

where

ffl

is

an

any

arbitrarily

small

constant

The

naive

parallel

version

of

Algorithm

requires

O

-LRB-

m

Rn

log

n

-RRB-

time

if

O

-LRB-

-RRB-

processors

are

available

where

R

is

the

size

of

Therefore

we

obtain

a

simple

parallel

algorithm

which

needs

O

-LRB-

m

Rn

log

n

-RRB-

time

with

O

-LRB-

-RRB-

processors

because

finding

a

shortest

path

between

two

vertices

requires

O

-LRB-

n

log

n

-RRB-

time

using

O

-LRB-

-RRB-

processors

But

we

observe

that

is

such

an

augmented

graph

each

time

we

just

put

a

new

edge

into

it

and

re-calculate

the

shortest

path

between

a

pair

of

vertices

on

this

augmented

graph

Therefore

we

can

use

the

partially

dynamic

parallel

algorithm

for

finding

all

pairs

shortest

paths

developed

by

Liang

McKay

and

Shen

-LSB-

-RSB-

which

claims

that

maintaining

all

pairs

shortest

paths

can

be

done

in

O

-LRB-

log

n

-RRB-

time

using

O

-LRB-

log

n

-RRB-

processors

Hence

we

obtain

the

following

lemma

Lemma

Given

a

weighted

connected

graph

G

-LRB-

V

E

-RRB-

finding

a

sparse

t-spanner

of

G

can

be

done

in

O

-LRB-

m

R

log

n

-RRB-

O

-LRB-

m

-LRB-

t

-RRB-

log

n

-RRB-

time

using

O

-LRB-

-RRB-

processors

The

size

and

the

weight

of

the

spanner

generated

are

O

-LRB-

-LRB-

t

-RRB-

-RRB-

and

O

-LRB-

n

ffl

t

wt

-LRB-

MST

-RRB-

-RRB-

respectively

where

ffl

-LRB-

-RRB-

is

an

any

arbitrarily

small

constant

Proof

Initially

we

compute

the

distance

matrix

of

G

It

can

be

easily

done

in

O

-LRB-

n

log

n

-RRB-

time

using

O

-LRB-

-RRB-

processors

Then

we

construct

n

single

source

shortest

path

trees

for

-LRB-

see

-LSB-

-RSB-

for

details

-RRB-

When

a

new

edge

is

inserted

into

we

update

the

distance

matrix

of

which

can

be

done

in

O

-LRB-

-RRB-

time

using

O

-LRB-

-RRB-

processors

then

maintaining

the

data

structures

for

n

single

source

shortest

path

trees

for

requires

O

-LRB-

log

n

-RRB-

time

and

O

-LRB-

log

n

-RRB-

processors

There

are

at

most

R

edges

to

be

inserted

into

and

R

O

-LRB-

-LRB-

t

-RRB-

-RRB-

-LSB-

-RSB-

While

deciding

whether

an

edge

of

G

belongs

to

can

be

done

in

O

-LRB-

-RRB-

time

by

checking

the

corresponding

entries

in

the

distance

matrices

of

both

G

and

Therefore

this

algorithm

requires

time

O

-LRB-

m

-LRB-

t

-RRB-

log

n

-RRB-

time

provided

that

O

-LRB-

-RRB-

processors

are

available

The

algorithm

for

finding

an

approximate

t-spanner

The

idea

for

finding

an

approximate

t-spanner

on

weighted

graphs

is

similar

to

that

for

unweighted

graphs

However

we

must

make

some

minor

changes

in

order

to

extend

our

algorithm

for

unweighted

graphs

to

weighted

graphs

At

this

moment

we

concentrate

on

the

construction

of

the

supergraph

in

each

phase

Instead

of

finding

an

arbitrary

edge

between

two

supervertices

served

as

an

edge

in

the

resulting

supergraph

an

edge

of

G

between

two

supervertices

is

selected

as

the

edge

in

the

supergraph

when

it

has

the

minimum

weight

among

all

edges

in

these

two

supervertices

The

algorithm

is

the

same

as

Algorithm

except

the

following

steps

Algorithm

Step

for

each

vertex

v

find

such

an

adjacent

neighbor

u

with

the

minimum

weight

compared

with

other

neighbors

and

set

D

-LRB-

v

-RRB-

u.

if

D

-LRB-

D

-LRB-

v

-RRB-

-RRB-

v

and

D

-LRB-

v

-RRB-

v

then

if

D

-LRB-

v

-RRB-

v

then

D

-LRB-

v

-RRB-

v

else

D

-LRB-

d

-LRB-

v

-RRB-

-RRB-

=D

-LRB-

v

-RRB-

As

a

result

we

obtain

a

forest

F

of

inverted

trees

Step

Construct

a

weighted

supergraph

G

-LRB-

V

E

-RRB-

such

that

each

subtree

is

a

supervertex

and

the

edge

-LRB-

u

v

-RRB-

is

selected

as

an

edge

of

E

if

-LRB-

i

-RRB-

u

Cu

and

v

Cv

-LRB-

ii

-RRB-

the

weight

of

the

edge

-LRB-

u

v

-RRB-

is

minimum

among

all

such

edges

between

Cu

and

Cv

Step

Find

a

t-spanner

on

the

resulting

weighted

supergraph

G

-LRB-

V

E

-RRB-

Now

we

analyze

the

computational

complexity

of

the

proposed

algorithm

Theorem

Given

a

connected

weighted

graph

G

-LRB-

V

E

-RRB-

let

D

be

the

maximum

edge

weight

of

the

minimum

spanning

tree

of

G

Then

finding

an

approximate

sparse

t-spanner

with

factor

O

-LRB-

Dtk

-RRB-

requires

O

-LRB-

n

tk

-RRB-

-LRB-

n

tk

-RRB-

-LRB-

t

-RRB-

log

n

-RRB-

time

and

O

-LRB-

-RRB-

processors

Proof

By

Algorithm

we

know

that

the

Step

-LCB-

Step

can

be

finished

in

O

-LRB-

k

t

log

n

-RRB-

time

using

O

-LRB-

m

n

-RRB-

processors

By

Lemma

the

Step

can

be

done

in

O

-LRB-

-LRB-

n

tk

-RRB-

-LRB-

n

tk

-RRB-

-LRB-

t

-RRB-

log

n

-RRB-

time

using

O

-LRB-

-RRB-

processors

Theorem

Let

SP

-LRB-

G

-RRB-

be

the

approximate

t-spanner

of

G

generated

by

Algorithm

for

fixed

k

The

size

of

SP

-LRB-

G

-RRB-

is

O

-LRB-

-LRB-

n

tk

-RRB-

-LRB-

t

-RRB-

n

-RRB-

the

weight

is

no

more

than

O

-LRB-

-LRB-

-LRB-

n

tk

-RRB-

ffl

t

-RRB-

wt

-LRB-

MST

-RRB-

-RRB-

and

the

factor

is

O

-LRB-

Dtk

-RRB-

where

ffl

is

an

any

arbitrarily

small

constant

Proof

By

the

same

argument

in

Section

we

know

that

the

number

of

supervertices

in

a

weighted

supergraph

is

at

most

half

of

the

number

of

that

in

its

immediately

precedent

supergraph

assuming

G

is

the

initial

supergraph

Let

the

current

supergraph

have

ni

vertices

-LRB-

n

-RRB-

Then

the

number

of

supervertices

of

the

resulting

supergraph

after

finishing

the

for

loop

is

at

most

O

-LRB-

nit

-RRB-

We

therefore

obtain

the

final

supergraph

with

O

-LRB-

n

tk

-RRB-

supervertices

after

finishing

the

while

loop

Note

that

for

fixed

i

jEi

jj

jEi

j

and

n

be

cause

each

Ei

j

is

the

edge

set

of

a

forest

So

tc

j

jEi

j

j

O

-LRB-

nti

-RRB-

Note

that

that

-LSB-

j

tc

i

k

Ei

j

ae

fe

e

is

an

edge

in

MSTg

Therefore

after

finishing

Step

we

obtain

a

supergraph

denote

by

with

O

-LRB-

n

tk

-RRB-

vertices

By

applying

the

analysis

in

-LSB-

-RSB-

we

know

the

weight

of

the

t-spanner

of

is

less

than

O

-LRB-

-LRB-

n

tk

-RRB-

ffl

t

wt

-LRB-

-RRB-

-RRB-

O

-LRB-

-LRB-

n

tk

-RRB-

ffl

t

wt

-LRB-

MST

-RRB-

-RRB-

because

wt

-LRB-

-RRB-

wt

-LRB-

MST

-RRB-

and

the

size

of

is

O

-LRB-

-LRB-

n

tk

-RRB-

-LRB-

t

-RRB-

-RRB-

where

is

the

minimum

spanning

tree

of

Now

we

calculate

the

factor

of

the

spanner

Let

dl

be

the

maximum

diameter

of

the

cluster

generated

in

the

lth

iteration

of

the

variable

j

for

fixed

i.

Initially

the

diameter

of

every

supervertex

is

at

most

when

i

where

D

The

equation

is

expressed

as

follows

di

i

tc

From

the

equation

above

we

derive

that

tc

-LRB-

D

-RRB-

O

-LRB-

Dt

-RRB-

Therefore

the

maximum

distance

of

two

adjacent

vertices

of

G

belonging

to

the

same

supervertex

in

is

at

most

O

-LRB-

Dtk

-RRB-

Thus

the

factor

of

the

resulting

spanner

of

G

is

O

-LRB-

t

-LRB-

Dtk

-RRB-

-RRB-

O

-LRB-

Dtk

-RRB-

NC

Algorithms

for

Finding

A

of

G

The

algorithm

for

unweighted

graphs

In

Corollary

we

already

obtained

an

NC

algorithm

for

finding

a

-LRB-

-RRB-

spanner

of

unweighted

graphs

with

size

O

-LRB-

-LRB-

nt

-RRB-

-RRB-

By

adjusting

the

upper

bound

of

j

in

Algorithm

to

tc

we

can

easily

derive

an

NC

algorithm

for

finding

a

-LRB-

-RRB-

spanner

with

size

O

-LRB-

-LRB-

nt

-RRB-

-RRB-

In

the

following

we

present

an

NC

algorithm

for

finding

a

of

G

with

size

O

-LRB-

maxfm

tg

-RRB-

which

is

obviously

worser

than

the

result

in

Corollary

However

the

motivation

that

we

develop

this

algorithm

is

to

use

it

as

a

subroutine

to

devise

an

NC

algorithm

for

finding

a

on

weighted

graphs

Let

G

-LRB-

V

E

-RRB-

be

the

original

graph

and

d

-LRB-

u

v

-RRB-

the

distance

between

vertices

u

and

v

in

G.

Assuming

that

G

does

not

contain

degree-one

vertices

Otherwise

we

can

delete

these

vertices

first

We

then

put

them

back

to

the

resulting

t-spanner

of

the

graph

formed

by

the

remaining

vertices

By

graph

G

-LRB-

V

E

-RRB-

we

construct

a

new

graph

Gi

-LRB-

V

Ei

-RRB-

such

that

an

edge

-LRB-

u

v

-RRB-

Ei

if

and

only

if

d

-LRB-

u

v

-RRB-

i

dlog

ne

Denote

by

Ui

a

maximal

independent

set

of

vertices

on

G

-LRB-

V

Ei

-RRB-

and

T

-LRB-

u

i

-RRB-

a

Breadth-First

Search

tree

rooted

at

u

with

height

in

G

-LRB-

V

E

-RRB-

Lemma

Given

a

connected

undirected

graph

G

-LRB-

V

E

-RRB-

the

construction

of

Gi

-LRB-

V

Ei

-RRB-

defined

above

can

be

done

in

O

-LRB-

i

-RRB-

time

using

O

-LRB-

-RRB-

processors

i

dlog

ne

Proof

Let

-LRB-

V

-RRB-

G

-LRB-

V

E

-RRB-

Assuming

that

Gi

already

exists

Now

we

construct

Gi

as

follows

for

any

two

vertices

u

and

v

we

add

to

Ei

the

edge

-LRB-

u

v

-RRB-

if

there

exists

at

least

one

vertex

w

-LRB-

w

u

and

v

-RRB-

such

that

edges

-LRB-

u

w

-RRB-

Ei

and

-LRB-

v

w

-RRB-

Ei

So

Gi

can

be

generated

in

O

-LRB-

-RRB-

time

using

O

-LRB-

-RRB-

processors

if

Gi

is

given

Lemma

Let

the

graph

Gblog

tc

-LRB-

V

Eblog

tc

-RRB-

be

defined

as

above

Then

for

any

two

non-adjacent

vertices

u

and

v

d

-LRB-

u

v

-RRB-

tc

t

The

proof

of

Lemma

is

so

obvious

we

omit

it

here

In

the

following

we

give

an

NC

algorithm

for

constructing

a

of

G

with

size

O

-LRB-

minfm

tg

-RRB-

Algorithm

Step

Construct

the

graph

Gblog

tc

-LRB-

V

Eblog

tc

-RRB-

Step

Find

a

maximal

independent

set

Ublog

tc

of

graph

Gblog

tc

in

parallel

Step

For

every

u

Ublog

tc

construct

a

Breadth-First

Search

tree

T

-LRB-

u

blog

tc

-RRB-

rooted

at

u

with

height

tc

in

G

-LRB-

V

E

-RRB-

Step

The

of

G

is

-LSB-

tc

-LRB-

u

blog

tc

-RRB-

Lemma

n

blog

tc

jUblog

tc

Proof

It

is

well

known

that

for

a

graph

G

with

the

maximum

degree

and

the

minimum

degree

ffi

the

size

of

a

maximal

independent

set

U

of

G

is

in

between

n

=-LRB-

-RRB-

and

n

ffi

Whereas

the

the

maximum

degree

and

the

minimum

degree

of

graph

Gblog

tc

are

blog

tc

and

ffiblog

tc

t

respectively

because

there

are

no

degree-one

vertices

in

G

The

lemma

follows

Let

Cover

-LRB-

u

blog

tc

-RRB-

be

a

vertex

set

consisting

of

all

vertices

in

T

-LRB-

u

blog

tc

-RRB-

and

u

be

defined

as

the

center

of

this

set

By

the

definition

in

Section

Cover

-LRB-

u

blog

tc

-RRB-

is

a

partial

cover

and

H

fCover

-LRB-

u

blog

tc

-RRB-

j

u

Ublog

tc

is

a

coarse

vertex

cover

on

V

Lemma

Let

v

be

a

vertex

belonging

to

covers

Xs

and

xi

be

the

center

of

Xi

where

Xi

H

and

s

i

jUblog

tc

Then

there

exists

at

most

a

partial

cover

Xj

such

that

d

-LRB-

v

xj

-RRB-

tc

and

d

-LRB-

v

xi

-RRB-

tc

for

all

other

Xi

with

i

j.

Proof

If

there

exists

two

vertices

xi

and

xj

such

that

d

-LRB-

v

xi

-RRB-

tc

and

d

-LRB-

v

xj

-RRB-

tc

Then

d

-LRB-

xi

xj

-RRB-

d

-LRB-

v

xi

-RRB-

d

-LRB-

v

xj

-RRB-

tc

By

the

construction

of

the

graph

Gblog

tc

there

must

have

an

edge

-LRB-

xi

xj

-RRB-

connected

these

two

vertices

which

contradicts

the

assumption

that

both

xi

and

xj

are

included

in

the

maximal

independent

set

Ublog

tc

Lemma

For

any

u

Ublog

tc

jCover

-LRB-

u

blog

tc

-RRB-

j

t

Proof

By

the

discussion

in

Lemma

the

degree

of

vertex

u

in

Gblog

tc

is

at

least

t

Recall

that

Cover

-LRB-

u

blog

tc

-RRB-

is

the

home

cover

of

vertex

v

if

v

Cover

-LRB-

u

blog

tc

-RRB-

Then

we

have

Lemma

Let

H

be

defined

as

above

Then

at

least

tjUblog

tc

vertices

has

only

one

home

cover

Proof

We

first

show

that

the

vertex

set

Ublog

tc

is

an

independent

set

of

graph

Gblog

tc

Without

loss

of

generation

assuming

that

vertices

u

v

Ublog

tc

are

adjacent

in

graph

Gblog

tc

Then

d

-LRB-

u

v

-RRB-

tc

so

they

must

be

adjacent

in

Gblog

tc

This

statement

contradicts

with

the

initial

assumption

that

Ublog

tc

is

a

maximal

independent

set

of

Gblog

tc

Recall

that

T

-LRB-

u

blog

tc

-RRB-

is

a

Breadth-First

Search

tree

rooted

at

u

with

height

tc

in

G

-LRB-

V

E

-RRB-

We

denote

by

Cover

-LRB-

u

blog

tc

-RRB-

the

set

of

all

vertices

in

T

-LRB-

u

blog

tc

-RRB-

Obviously

Cover

-LRB-

u

blog

tc

-RRB-

Cover

-LRB-

u

blog

tc

-RRB-

Now

we

prove

that

for

any

u

and

v

-LRB-

u

v

Ublog

tc

and

u

v

-RRB-

Cover

-LRB-

u

blog

tc

-RRB-

Cover

-LRB-

v

blog

tc

-RRB-

O

If

not

there

exists

at

least

one

vertex

w

Cover

-LRB-

u

blog

tc

-RRB-

Cover

-LRB-

v

blog

tc

-RRB-

Then

d

-LRB-

u

v

-RRB-

d

-LRB-

v

w

-RRB-

d

-LRB-

v

w

-RRB-

tc

blog

tc

tc

By

the

construction

of

the

graph

Gblog

tc

u

and

v

must

be

adjacent

in

this

graph

Contradiction

While

jCover

-LRB-

v

blog

tc

-RRB-

j

t

by

the

similar

discussion

as

in

Lemma

We

therefore

conclude

that

at

least

tjUblog

tc

vertices

belong

to

one

home

cover

only

Theorem

The

spanner

generated

by

Algorithm

has

size

of

O

-LRB-

minfm

tg

-RRB-

and

factor

of

Proof

By

Lemma

jUblog

tc

t

and

a

vertex

v

V

belongs

to

at

most

t

home

covers

Therefore

the

size

of

the

resulting

spanner

is

O

-LRB-

minfm

t

g

-RRB-

Now

we

show

that

the

factor

of

the

resulting

spanner

is

To

achieve

this

bound

we

only

show

that

for

every

two

vertices

u

and

v

such

that

d

-LRB-

u

v

-RRB-

tc

there

exists

at

least

a

home

cover

X

H

including

these

two

vertices

That

means

the

distance

between

u

and

v

in

the

spanner

is

no

more

than

The

proof

is

as

follows

By

Lemma

it

is

impossible

that

both

u

and

v

are

in

Ublog

tc

So

we

discuss

it

by

four

cases

-LRB-

i

-RRB-

If

either

one

of

them

is

in

Ublog

tc

say

u

Ublog

tc

then

v

is

in

the

home

cover

of

u

because

d

-LRB-

u

v

-RRB-

tc

As

a

result

the

distance

between

these

two

vertices

in

the

spanner

is

no

more

than

tc

t.

-LRB-

ii

-RRB-

If

neither

u

nor

v

is

in

Ublog

tc

but

their

common

neighbor

w

of

Gblog

tc

is

in

Ublog

tc

then

w

is

the

center

of

their

home

cover

because

d

-LRB-

v

w

-RRB-

tc

and

d

-LRB-

u

w

-RRB-

tc

the

theorem

follows

-LRB-

iii

-RRB-

If

w

is

a

neighboring

vertex

of

u

but

v

in

Gblog

tc

We

claim

that

v

also

belongs

to

the

home

cover

centered

at

w

because

d

-LRB-

v

w

-RRB-

d

-LRB-

w

u

-RRB-

d

-LRB-

u

v

-RRB-

tc

blog

tc

tc

-LRB-

iv

-RRB-

Otherwise

the

distance

between

a

vertex

in

Ublog

tc

and

u

-LRB-

or

v

-RRB-

in

Gblog

tc

is

at

least

larger

than

Then

either

u

or

v

must

belong

to

Ublog

tc

because

Ublog

tc

is

a

maximal

independent

set

of

graph

Gblog

tc

Contradiction

The

algorithm

for

weighted

graphs

Though

the

algorithm

in

-LSB-

-RSB-

is

very

simple

and

efficient

it

seems

to

be

inherently

sequential

Based

on

the

neighborhood

cover

of

Awerbuch

and

Peleg

-LSB-

-RSB-

Cohen

-LSB-

-RSB-

introduces

the

pairwise

cover

concept

and

presents

an

efficient

sequential

algorithm

and

a

randomized

parallel

algorithm

for

finding

a

sparse

t-spanner

in

weighted

graphs

The

basic

idea

of

Cohen

's

algorithm

is

to

employ

a

logarithmic

number

of

pairwise

covers

for

different

values

of

W

to

construct

spanners

Define

the

radii

of

a

partial

cover

X

by

the

distance

from

the

center

of

X

to

the

farthest

vertex

in

it

Let

be

any

constant

bounded

by

Cohen

's

algorithm

is

described

as

follows

Algorithm

Step

Initialization

Step

Wmax

maxfwt

-LRB-

e

-RRB-

j

e

Eg

Wmin

minfwt

-LRB-

e

-RRB-

j

e

Eg

R

-LRB-

Wmax

Wmin

-RRB-

e

Step

for

i

to

R

do

in

parallel

Wi

Wmin

-LRB-

-RRB-

i

endfor

Step

for

i

to

R

do

in

parallel

Construct

a

coarse

vertex

cover

Hi

such

that

the

radii

of

every

partial

cover

X

Hi

is

no

more

than

tcWi

endfor

Step

The

spanner

generated

is

-LSB-

ri

-LRB-

u

blog

tc

-RRB-

j

u

is

the

center

ofX

and

X

Hig

The

correctness

of

the

above

algorithm

is

testified

in

-LSB-

-RSB-

The

key

part

of

this

algorithm

is

how

to

construct

a

coarse

vertex

cover

on

V

-LRB-

called

pairwise

cover

in

Cohen

's

algorithm

-RRB-

efficiently

in

parallel

As

for

this

Cohen

-LSB-

-RSB-

introduces

randomness

to

chose

the

centers

of

covers

However

it

seems

not

easy

to

transform

her

randomized

parallel

algorithm

into

a

deterministic

version

Here

we

present

an

efficient

deterministic

parallel

algorithm

for

constructing

such

a

coarse

vertex

cover

by

extending

our

technique

for

unweighted

graphs

to

weighted

graphs

Let

A

be

the

adjacent

weighted

matrix

of

G

and

Ai

Ai

JAi

where

J

operation

function

is

defined

as

follows

ai

-LRB-

u

v

-RRB-

fai

-LRB-

u

v

-RRB-

ai

-LRB-

u

w

-RRB-

ai

-LRB-

w

v

-RRB-

g

and

an

entry

ai

-LRB-

u

v

-RRB-

of

Ai

represents

the

distance

between

u

and

v

with

at

most

edges

Assuming

A

Then

a

coarse

vertex

cover

Hi

is

constructed

as

follows

Algorithm

Step

Construct

an

auxiliary

graph

Gi

-LRB-

V

E

-RRB-

We

add

to

E

the

edge

-LRB-

u

v

-RRB-

if

and

only

if

d

-LRB-

u

v

-RRB-

tc

Step

Find

a

maximal

independent

set

U

-LRB-

i

blog

tc

-RRB-

of

Gi

-LRB-

V

E

-RRB-

in

parallel

Step

Build

a

shortest

path

tree

rooted

at

u

Ti

-LRB-

u

blog

tc

-RRB-

with

height

tcWi

in

G

-LRB-

V

E

-RRB-

for

each

u

U

-LRB-

i

blog

tc

-RRB-

such

that

a

vertex

v

is

included

in

this

tree

if

and

only

if

d

-LRB-

u

v

-RRB-

tcWi

Step

The

coarse

vertex

cover

Hi

fCoveri

-LRB-

u

blog

tc

-RRB-

j

u

U

-LRB-

i

blog

tc

-RRB-

g

is

built

Lemma

Given

a

weighted

graph

G

-LRB-

V

E

-RRB-

with

respect

to

parameters

t

and

Wi

it

can

be

done

in

O

-LRB-

n

-RRB-

time

using

O

-LRB-

-RRB-

processors

for

constructing

a

coarse

vertex

cover

Hi

such

that

two

vertices

u

and

u

are

included

in

one

home

cover

X

at

least

if

d

-LRB-

u

v

-RRB-

tc

for

fixed

i

where

X

Hi

Proof

By

Algorithm

we

know

that

the

Step

can

be

finished

in

O

-LRB-

log

n

log

t

-RRB-

time

using

O

-LRB-

-RRB-

processors

The

details

are

as

follows

First

compute

the

matrix

Ablog

tc

which

requires

O

-LRB-

log

n

log

t

-RRB-

time

using

O

-LRB-

-RRB-

processors

Then

construct

the

graph

Gi

-LRB-

V

E

-RRB-

which

requires

O

-LRB-

-RRB-

time

using

O

-LRB-

-RRB-

processors

The

Step

can

be

done

in

O

-LRB-

n

-RRB-

tine

using

O

-LRB-

log

n

-RRB-

processors

by

the

algorithm

of

Goldberg

and

Spencer

-LSB-

-RSB-

The

processing

of

the

Step

is

more

involved

For

every

vertex

u

U

-LRB-

i

blog

tc

-RRB-

we

build

an

inverted

tree

rooted

at

u

Ti

-LRB-

u

blog

tc

-RRB-

initially

Then

we

check

a

vertex

v

V

to

see

whether

v

Ti

-LRB-

u

blog

tc

-RRB-

by

testing

ai

-LRB-

u

v

-RRB-

tcWi

If

it

does

we

find

the

parent

p

-LRB-

u

v

-RRB-

of

v

in

this

tree

where

p

-LRB-

u

v

-RRB-

is

such

a

vertex

w

that

ai

-LRB-

u

v

-RRB-

ai

-LRB-

u

w

-RRB-

wt

-LRB-

-LRB-

w

v

-RRB-

-RRB-

There

are

at

most

jU

-LRB-

i

blog

tc

-RRB-

j

n

trees

and

for

each

vertex

finding

its

parent

in

a

tree

can

be

done

in

O

-LRB-

log

n

-RRB-

time

using

O

-LRB-

n

-RRB-

processors

So

the

Step

requires

O

-LRB-

log

n

-RRB-

time

and

O

-LRB-

-RRB-

processors

Step

can

be

done

in

O

-LRB-

-RRB-

time

using

O

-LRB-

-RRB-

processors

Theorem

For

a

weighted

connected

graph

G

-LRB-

V

E

-RRB-

with

non-negative

weights

the

spanner

generated

by

Algorithm

and

Algorithm

has

size

of

O

-LRB-

minfm

t

ffl

-LRB-

Wmax

Wmin

-RRB-

g

-RRB-

and

factor

of

where

ffl

is

a

constant

with

ffl

Proof

The

proof

is

similar

to

Theorem

Omitted

Note

that

Theorem

holds

only

if

the

edges

weights

of

graph

G

are

independent

of

n.

Besides

that

we

fail

to

make

comparison

of

the

weight

of

the

spanner

with

wt

-LRB-

MST

-RRB-

Conclusions

In

this

paper

we

first

introduce

the

approximate

t-spanner

concept

and

present

simple

parallel

algorithms

for

finding

such

an

approximate

t-spanner

in

both

unweighted

graphs

and

weighted

graphs

The

algorithms

exhibit

a

trade-off

between

the

running

time

and

the

factor

of

the

spanner

generated

Then

we

present

an

NC

algorithm

for

finding

a

on

a

weighted

graph

It

is

very

interesting

to

investigate

whether

the

problem

for

finding

a

sparse

t-spanner

on

both

unweighted

graphs

and

weighted

graphs

is

in

NC

is

still

open

References

-LSB-

-RSB-

I.

Alth

-RCB-

ofer

G.

Das

D.

Dobkin

D.

Joseph

and

J.

Soares

On

sparse

spanners

of

weighted

graphs

Discrete

and

Computational

Geometry

Vol

pp.

-LSB-

-RSB-

S.

Arya

and

M.

Smid

Efficient

construction

of

a

bounded

degree

spanner

with

low

weight

ESA

LNCS

-LSB-

-RSB-

B.

Awerbuch

Complexity

of

network

synchronization

J.

Assoc.

for

Computing

Machinery

Vol

No.

pp.

-LSB-

-RSB-

B.

Awerbuch

A.

Bar-Noy

N.

Linial

and

D.

Peleg

Compact

distributed

data

structures

for

adaptive

routing

Proc

ACM

Annual

Sympo

on

Theory

of

Computing

-LSB-

-RSB-

B.

Awerbuch

and

D.

Peleg

Routing

with

polynomial

communication-space

trade-off

SIAM

J.

Discrete

Math.

Vol

No.

-LSB-

-RSB-

B.

Awerbuch

and

D.

Peleg

Sparse

partitions

Proc

IEEE

Annual

Sympo

on

Foundations

of

Computer

Science

IEEE

-LSB-

-RSB-

B.

Chandra

G.

Das

G.

Narasimhan

and

J.

Soares

New

sparseness

results

on

graph

spanners

Proc

Annual

ACM

Sympo

on

Computational

Geometry

pp.

-LSB-

-RSB-

E.

Cohen

Fast

algorithms

for

constructing

t-spanners

and

paths

with

t

Proc

IEEE

Annual

Sympo

on

Foundations

of

Computer

Science

-LSB-

-RSB-

D.

Coppersmith

and

S.

Winograd

Matrix

multiplication

via

arithmetic

progressions

Proc

Annual

ACM

Sympo

on

Theory

Computing

pp.

-LSB-

-RSB-

G.

Das

and

P.

J.

Heffernan

Constructing

spanners

with

other

sparseness

properties

Interna

Sympo

on

Algorithms

and

Computations

Vol

LNCS

-LSB-

-RSB-

G.

Das

and

G.

Narasimhan

A

fast

algorithm

for

constructing

sparse

Euclidean

spanners

Proc

Annual

ACM

Sympo

on

Computational

Geometry

-LSB-

-RSB-

M.

L.

Fredman

and

R.E.

Tarjan

Fibonacci

heaps

and

their

uses

in

improved

network

optimalization

problems

J.

ACM

Vol

-LSB-

-RSB-

W.

Liang

B.

McKay

and

H.

Shen

NC

algorithms

for

dynamically

solving

the

all

pairs

shortest

path

problem

and

related

problems

Unpublished

manscript

Aug.

-LSB-

-RSB-

D.

Peleg

and

A.

A.

Sch

-RCB-

affer

Graph

spanners

J.

Graph

Theory

Vol

No.

-LSB-

-RSB-

D.

Peleg

and

J.

Ullman

An

optimal

synchronizer

for

the

hypercube

SIAM

J.

Comput.

Vol

pp.

-LSB-

-RSB-

D.

Peleg

and

E.

Upfal

A

trade-off

between

space

and

efficiency

for

routing

tables

J.

ACM

Vol

No.

-LSB-

-RSB-

P.

M.

Vaidya

A

sparse

graph

almost

as

good

as

the

complete

graph

on

points

in

K

dimensions

Discrete

and

Computational

Geometry

Vol

-LSB-

-RSB-

M.

Goldberg

and

T.

Spencer

Constructing

a

maximal

independent

set

in

parallel

SIAM

J.

Discrete

Math.

Vol