uvelichitel

Зрелищный и простой - Boids.
Оптимизационные - алгоритм муравья, алгоритм роя.
Точная математика - интегрирование Верле.

Задача рюкзака вообще NPполная, на PHP будет считаться веками. В вашей частной формулировке задача решается без замысловатых алгоритмов. Считайте эталонной упаковкой - два больших квадрата(их больше не влезет) на которых лежат две палки(больше не влезет). Далее большой квадрат может быть заменен двумя палками, а палка двумя малыми квадратами - так вы получите дерево всех оптимальных решений. Оно небольшое.

Go изначально concurrent. Из коробки лучше масштабируется. Например для двух ядер что нибудь вроде

var Data []uint64             //700 млн 64бит uint значений
var Respond []uint64      //значения около 100.000 на каждый запрос
var res chan uint64         //канал передачи годных значений
func TakeFromData(DataPart []uint64, res chan uint64){  //функция фильтра которой передается часть данных и канал годных
       for _, val := range DtaPart{
              if Good(val){
                       res <- val           //пишет годные в канал
              }
      }
}
go TakeFromData(Data[:len(Data)/2], res)    //запускается конкурентно в отдельном потоке
go TakeFromData(Data[len(Data)/2:], res)    // несколько экземпляров
for val:=range res{                    //агрегатор в своем потоке читает из канала по мере фильтрации
    Respond:=append(Respond, val)            //и формирует результат
}

Конечно можно написать multithreaded на С, только мороки будет больше.

Наверное что нибудь такое? Оно работает play.golang.org/p/Zo3jD2T8j8

type State struct {
	state  int
	step   int
	states []int
}
func NewState(states []int) *State {
	return &State{
		0,
		states[0],
		states,
	}
}
func (s *State) update() {
	if s.step > 0 {
		s.step--
		fmt.Println("step=", s.step) //do something
	} else {
		s.changestate()
		fmt.Println("state=", s.state) //do something else
	}
}
func (s *State) changestate() {
	if s.state < len(s.states)-1 {
		s.state++
	} else {
		s.state = 0
	}
	s.step = s.states[s.state]
}
func main() {
	st := NewState([]int{4, 2, 3, 4})
	st.update()
}

В комментариях вы уточнили, что интересует оптимальный путь. Оптимальный путь обходом в ширину это алгоритм Дейкстры. Вкратце, в стек(вектор пути) в позицию каждой вершины записывается имя последней предыдущей на кратчайшем пути. Подробно описано например здесь https://habrahabr.ru/post/111361/

Применяются еще Декартово расстояние = корень из суммы квадратов отклонений элементов, расстояние Хэмминга = число элементов с отклонением > дельта.

• Начинать так - прогуглить пяток сортировок и реализовать на языке на котором пишете, потом написать свою как оптимизированную композицию двух существующих и опубликовать на хабре, так все начинают.))
  
• Осваивать например с Седжвиком или Корменом. Седжвик есть под Java и есть под C++, на coursera есть бесплатный курс, читает автор на Java.
  
• Вирт - это библия, у каждого должна иметься, но редко кто осилил от корки до корки, написано под С.
  
• С теорией вычислений в массачусетском технологическом знакомятся по SICP. Книжка под scheme, переведена на русский. Есть курс начитанный авторами. На scheme вы потом вряд ли будете писать, но это как pascal в российских школах.
  
• Исследование алгоритма, то есть доказательство его корректности, оценка NP-сложности, поиск плохих и хороших для него наборов данных выполняется математическими и статистическими методами в основном на бумаге с калькулятором, но что нибудь специально_функциональное вроде Haskell, MatLab наверное могут помочь. На практике этим(исследованием) редко занимаются - работает и в продакшн.))
  

Слегка можно оптимизировать

def solution(A):
    total_sum = 0
    a = 1
    b = 1
    for i in range(0, A - A % 3):           
        temporary = a
        a = b
        b += temporary
    total_sum = b // 2
    return sum_of_digits(total_sum)

Кажется такая штука называется lexer и parser. Например Lexx Yacc Bison. Или модный нынче PEG