使用std :: sort和std :: next_permutation

Question

I have the following code which i wrote and works perfectly. I just have trouble understanding why it works. More specifically, why must we first sort the array in order to use std::next_permutation, can it not start from any configuration ?

And the part which bothers me the most is that I don't understand why we must write sort(sides, sides+3) and next_permutation(sides, sides+3) why the "+3"! because I have three elements in the array ? What if i was using an arbitrary number of elements ?

bool valid(int sides[], ofstream &outfile)
{
  int i = 0;
  for(; i < 3; i++) {
    if(sides[i] <= 0) {
      outfile << "This is not a valid triangle because it\n "
              << "contains negative sides or contains a\n"
              << "side length of 0\n\n";
      return false;
    }
  }

  do{
    std::sort(sides,sides+3);
    if(sides[0] + sides[1] > sides[2])
      ;
    else{
      outfile << "This is not a valid triangle because "
              << sides[0] << " + " << sides[1]
              << " is not greater than " << sides[2];
      return false;
    }
  }while(std::next_permutation(sides,sides+3));

  return true;
}

Answer 1

Euclidian geometry tells us that:
the sum of two sides is always greater than the remaining side

Lets take a triangle ABC.
AB = 3
BC = 5
AC = 4

std::sort will sort the sides into ascending order. So that the array will contain the shorter sides first.

after sort
side[0] = AB = 3
side[1] = AC = 4
side[2] = BC = 5

std::next_permutation returns the next possible combination of the sides.For instance:

AC = 3
BC = 5
AB = 4

A quick example:

#include <iostream>     // std::cout
#include <algorithm>    // std::next_permutation, std::sort

int main () {
  int myints[] = {1,2,3};

  std::sort (myints,myints+3);

  std::cout << "The 3! possible permutations with 3 elements:\n";

  while ( std::next_permutation(myints,myints+3) )
  {
    std::cout << myints[0] << ' ' << myints[1];
    std::cout << ' ' << myints[2] << '\n';
  }

  std::cout << "After loop: " << myints[0] << ' ';
  std::cout << myints[1] << ' ' << myints[2] << '\n';

  return 0;
}

Further reading: http://www.cplusplus.com/reference/algorithm/next_permutation/

Answer 2

the std::next_permutation documentation

Transform range to next permutation Rearranges the elements in the range [first,last) into the next lexicographically greater permutation.

so unless you start sorted you won't go through all permutations

So if you start with

1,2,3

that last permutation would be

3,2,1

if you start from

3,1,2

only one more permutation will be found and not all

Answer 3

Take a look at the results of std::next_permuntation when you don't sort it:

#include <algorithm>
#include <iostream>
#include <iterator>
#include <string>

enum class sort { no, yes };

void show_permutations(std::string s, sort option) {
  if (sort::yes == option) {
    std::sort(std::begin(s), std::end(s));
  }

  do {
    std::cout << s << '\n';
  } while (std::next_permutation(std::begin(s), std::end(s)));
}

int main() {
  show_permutations("3412", sort::yes);

  std::cout << "Now without sorting...\n";

  show_permutations("3412", sort::no);
}

Examine the output to see if you notice anything interesting:

1234
1243
1324
1342
1423
1432
2134
2143
2314
2341
2413
2431
3124
3142
3214
3241
3412
3421
4123
4132
4213
4231
4312
4321
Now without sorting...
3412
3421
4123
4132
4213
4231
4312
4321

The sequence created without sorting is the same as just the very end of the sequence created with sorting. What does that imply about the importance of the input's ordering?

---

What do you think would happen if you put the sorting code inside the loop?

void show_permutations(std::string s, sort option) {
  do {

    if (sort::yes == option) {
      std::sort(std::begin(s), std::end(s));
    }

    std::cout << s << '\n';
  } while (std::next_permutation(std::begin(s), std::end(s)));
}

Notice that your program sorts the triangle sides inside the next_permutation loop similar to this code sorting the input string inside the loop.