/*********************************************************************/
/* shc.c: Steepest Hill Climbing                                     */
/* Retunerer antal bytninger.                                        */
/*********************************************************************/

int shc(int schedule[])
{
  int badcost, bettercost, id, i, j, k, l, ct=0, stop;
  int swapfrom[NUMSHIFTS+1], swapto[NUMSHIFTS+1], candidate[NUMEMPLOYEES+1];

  //Loop BAD_COST fra 10 til 2
  for (badcost = 10; badcost >= 2; badcost--)
    {
      //permutate(schedule);
      //Lav en liste SWAP_FROM over alle vagter med cost BAD_COST
      initarray(swapfrom);
      for (l = 0; l < NUMSHIFTS; l++)
        {
          if (worker[schedule[l]].pref[l] == badcost)
            {
              add_element(l, swapfrom);
            }
        }
      //Bland elementerne i SWAP_FROM tilfldigt
      randomize(swapfrom);
      //Hvis |SWAP_FROM| > 0
      int ssf = count(swapfrom);
      if (ssf > 0)
        {
          //Loop over SWAP_FROM
          for (i = 0; i < ssf; i++)
            {
              stop = 0;
              //Find id'et ID for medarbejderen p SWAP_FROM*
              id = schedule[swapfrom[i]];
              //Loop BETTER_COST fra 1 til BAD_COST-1
              for (bettercost = 1; (bettercost < badcost) && !(stop); bettercost++)
                {
                  //Lav en liste CANDIDATE over medarbejdere der har vgt BETTER_COST p vagt SWAP_FROM*
                  initarray(candidate);
                  for (l = 0; l < NUMEMPLOYEES; l++)
                    if (worker[l].pref[swapfrom[i]] == bettercost)
                      {
                        add_element(l, candidate);
                      }

                  //Hvis |CANDIDATE| > 0
                  if (count(candidate) > 0)
                    {
                      //Bland elementerne i CANDIDATE tilfldigt
                      randomize(candidate);
                      //Loop over CANDIDATE
                      int sc = count(candidate);
                      for (j = 0; (j < sc) && !(stop); j++)
                        {
                          //Lav en liste SWAP_TO over vagter CANDIDATE* sider p, som ID har vgt < BAD_COST p
                          initarray(swapto);
                          for (l = 0; l < NUMSHIFTS; l++)
                            //for ikke at overskrive elementer i swapform tilfjes de ikke til swapto.
                            if ((schedule[l] == candidate[j]) && (worker[id].pref[l] < badcost) && (worker[candidate[j]].pref[l] != badcost))
                              add_element(l, swapto);

                          //Hvis |SWAP_TO| > 0
                          int sst = count(swapto);
                          if (sst > 0)
                            {
                              //Sorter SWAP_TO min->max efter ID's vgtning
                              pref_sort(id, swapto);
                              //Loop over SWAP_TO
                              for (k = 0; (k < sst) && !(stop); k++)
                                {
                                  //Hvis det er lovligt at bytte SWAP_FROM* og SWAP_TO*
                                  if ((check_valid_swap(swapfrom[i], swapto[k], schedule)))
                                    {
                                      //Byt SWAP_FROM* og SWAP_TO*  
                                      swap_shifts(swapfrom[i], swapto[k], schedule);

                                      ct++;
                                      //Break helt ud til Loop-SWAP_FROM
                                      stop = 1;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
  return ct;
}