;;; Michael Wollowski
;;; 5.ss

(define (rl) (load "5.ss"))

(define gr '((a (b c)) (b (a)) (c (a)) (d ())))

(define connected?
  (lambda (g)
    (cond [(null? g)]
	  [(and (null? (cdr g))
		(null? (cdar g)))]
	  [else (let* ([nodes (map car g)]
		       [startEndPoints (make_start_end_points nodes)])
		  (paths? startEndPoints g))])))

(define make_start_end_points
  (lambda (l)
    (if (null? (cdr l))
	'()
	(append (map (lambda (x) (list (car l) x)) (cdr l))
		(make_start_end_points (cdr l))))))


(define paths?
  (lambda (SEPoints g)
    (if (null? SEPoints)
	#t
	(and (path? (cadar SEPoints) g (list (caar SEPoints)) '())
	     (paths? (cdr SEPoints) g)))))


(define path?
  (lambda (endPoint g openqueue closedqueue)
    (cond [(null? openqueue) #f]
	  [(eq? (car openqueue) endPoint) #t]
	  [else (path? endPoint
		       g
		       (add_to_open (get_neighbors (car openqueue) g) openqueue closedqueue)
		       (cons (car openqueue) closedqueue))])))
		       

(define add_to_open
  (lambda (nodes open closed)
    (cond [(null? nodes) (cdr open)]
	  [(or (memq (car nodes) open)
	       (memq (car nodes) closed))
	   (add_to_open (cdr nodes) open closed)]
	  [else (append (add_to_open (cdr nodes) open closed) (list (car nodes)))])))

(define add_to_open_tail
  (lambda (nodes open closed accu)
    (cond [(null? nodes) (append (cdr open) accu)]
	  [(or (memq (car nodes) open)
	       (memq (car nodes) closed))
	   (add_to_open_tail (cdr nodes) open closed accu)]
	  [else (add_to_open_tail (cdr nodes) open closed (cons (car nodes) accu))])))


(define get_neighbors
  (lambda (e g)
    (cond [(null? g) '()]
	  [(eq? e (caar g)) (cadar g)]
	  [else (get_neighbors e (cdr g))])))


(define make-slist-leaf-iterator
  (lambda (ls)
    (let ([stack (make-stack)])
      (stack 'push ls)
      (letrec ([iterator (lambda ()
			   (if (stack 'empty?)
			       #f
			       (let ([top (stack 'pop)])
				 (if (null? top)
				     (iterator)
				     (if (symbol? (car top))
					 (begin (stack 'push (cdr top))
						(car top))
					 (begin (stack 'push (cdr top))
						(stack 'push (car top))
						(iterator)))))))])
	iterator))))


(define make-stack
  (lambda ()
    (let ([stk '()])
      (lambda (msg  . args )
	(case msg
	  [(empty?) (null? stk)]
	  [(push)   (set! stk (cons (car args) stk))]
	  [(pop)    (let ([top (car stk)])
		      (set! stk (cdr stk))
		      top)]
	  [else (error 'stack "illegal message to stack object: ~a" msg)])))))



(define subst-leftmost
  (lambda (n o l p)
    (let ([done #f])
      (letrec ([sl2 (lambda (new old lst pred?)
		      (if (null? lst)
			  '()
			  (if (atom? (car lst))
			      (if (pred? (car lst) old)
				  (begin
				    (set! done #t)
				    (cons new (cdr lst)))
				  (cons (car lst) (sl2 new old (cdr lst) pred?)))
			      (let ([newls (sl2 new old (car lst) pred?)])
				(if (not done)
				    (cons newls (sl2 new old (cdr lst) pred?))
				    (cons newls (cdr lst)))))))])
	(sl2 n o l p)))))