Para guardar cualquier información en un archivo tienes que realizar los siguientes pasos:

• Incluir los archivos de cabecera necesarios:

#include <iostream> // Para entrada y salida de datos: cout / cin
#include <fstream> // Para flujos de entrada (ifstream) y salida (ofstream)
#include <cstdlib> // Para la funcion exit() y la constante EXIT_FAILURE
 
using namespace std; 

• Abrir el flujo de salida:

string nombreFichero = "salida.txt";
ofstream fichero(nombreFichero); 

Puedes definir una ruta en el nombre del archivo si quieres que se cree en otra diferente a la actual.

• Comprobar que se ha abierto correctamente:

if(!fichero){
  cout << "Error al abrir el fichero: " << nombreFichero << endl;
  exit(EXIT_FAILURE);
} 

• Guardar los datos que quieras en el fichero:

for(size_t i = 0; i < filas; ++i){
  for(size_t j = 0; j < columnas; ++j){
    fichero << matriz[i][j] << "  ";
  }
  fichero << endl;
} 

• Cerrar el flujo:

 fichero.close(); 

Problema 1: la variable <fila> no está inicializada. Tienes que darle un valor. No puedes crear la matriz primero en la línea 9 y pedir el número de filas que tendrá en la función que llamas después (línea 10).
Además es recomendable que utilices constantes o variables para guardar los datos, por ejemplo, el 3. Así si quieres cambiar dicho valor solo tendrás que cambiarlo en el lugar en el que declaras la variable/constante y no a lo largo de todo el programa. Digamos que es una buena práctica.

Consejo: Si la función es llenar(), que se encargue únicamente de rellenar la matriz. No tiene sentido que metas todo el programa dentro de dicha función. Separando el programa correctamente en funciones te será más fácil encontrar posibles errores en el futuro o poder hacer modificaciones en tu código.

Problema 2: El método para ordenar la matriz.
Lo mejor es tratar la matriz como un array unidimensional. Puedes utilizar un único índice que recorra todos los elementos.

for(int i = 0; i < FILAS * COLUMNAS; ++i){
  cout << "Fila: " << i / COLUMNAS << " - Columna: " << i % COLUMNAS << endl;
} 

Utilizando esto puedes implementar el algoritmo burbuja como si de un array unidimensional se tratara. Te dejo el pseudocódigo para que lo conviertas a C++:

Prueba a implementar el algoritmo en C++. Seguro que funciona.

---

PD: Al poner en el pseudocódigo (filas * columnas - 1) se incluye dicho valor. En C++ sería equivalente poner cualquiera de las dos siguientes expresiones:

for(int i = 1; i < filas * columnas; ++i){...}
for(int i = 1; i <= filas * columnas - 1; ++i){...} 

Para que no aparezcan puntos repetidos tienes varias opciones.
1. Seguir usando vectores y comprobar manualmente que no se muestren repetidos. Para ello a su vez tienes dos formas de conseguirlo, por lo pronto:
- Cuando (operacion = operacion_max), antes de insertar los nuevos x e y, compruebas que no existen ya.

- La otra opción sería guardarlos todos y a la hora de mostrar comprobar que el elemento actual que vas a mostrar no lo has mostrado ya. La idea es la misma pero ahora tendrías que recorrer desde la actual hacia el inicio. Puedes probarlo pero es menos eficiente ya que estás gastando más memoria al guardarlos repetidos.

2. Crear una class/struct que guarde x e y. Y sustituir ambos vectores por un SET de la STL (http://www.cplusplus.com/reference/set/set/?kw=set).
Desde luego, esta opción es mejor que las anteriores. Primero porque es la más eficiente y segundo porque te permite demostrar un mayor dominio del lenguaje sabiendo encapsular la información dentro de un objeto y eligiendo la mejor estructura de datos para tu propósito.
La ventaja principal del SET es que no guarda valores repetidos. Si tienes una class/struct tal que:

class Punto {
  private:
    int x;
    int y;
  //...
} 

Y defines el operador de igualdad como que un Punto P1 es igual a un Punto P2 cuando ambos atributos (x e y) son iguales. Hecho esto será el SET el que se encargará cada vez que quieras meter un Punto en su interior de comprobar si ya existe un punto igual a ese. De existir, no lo meterá. Todo esto último sin que tú tengas que hacer nada más.

Te dejo que investigues por tu cuenta. Da más satisfacción si lo consigues tú que si te lo dan hecho.
Suerte.

En el segundo caso, si la operación actual es igual a la operación máxima, no tienes que vaciar los vectores usando clear() porque entonces te estarás cargando el resto de valores. El clear() es solo para cuando encuentras una operacion > operacion_max.

Además al final en vez de mostrar x_max, y_max, que son variables simples que contienen un único valor cada una (concretamente el último punto que cumpla la lógica del ejercicio), debes recorrer ambos vectores al mismo tiempo e ir mostrando cada uno de sus elementos.

Suerte.

Utiliza las etiquetas de Código GeSHi para poner tu código. Tal y como está es imposible de interpretar...

Puedo ver que estás utilizando variables que no aparecen en ningún sitio. Estás seguro de que esas variables existen, es decir, que están declaradas como atributos de la clase??
Expón cuál es la lógica del método al menos. Sino es imposible saber qué es lo que quieres hacer. Deberías detallar qué precondiciones/postcondiciones debe cumplir tu método (es algo fundamental sobre todo en proyectos desarrollados por varias personas) para que todo funcione bien al unirlo.

Para colocar códigos utiiza las etiquetas de Código GeSHi (desplegable encima del cuadro de texto)

Tu propósito es trabajar con matrices cuadradas por lo que parece. Entonces no tiene sentido que pidas filas y columnas ya que podrían ponerte números diferentes y hacer que el programa falle. Es mejor que pidas un único valor que sea el orden de la matriz, es decir, el número de filas y columnas.

Si quieres recorrer la diagonal de una matriz cuadrada verás que las casillas que quieres recorrer son: (0,0), (1,1), (2,2),...; es decir, la i y la j avanzan a la vez o lo que es lo mismo solo utilizas una variable en el bucle:

for(int i = 0; i < orden; ++i){
  matriz[i][i] = 1;
} 

Si quieres guardar los valores en otro array, tendrás que crearlo. Y si quieres guardar los valores originales poner la instrucción antes de modificar los valores por 1s y si lo que quieres guardar son los 1s (que no tiene mucho sentido) pues después:

#DEFINE SIZE 100 // Usa constantes para los numeros que aparezcan sueltos. Asi puedes cambiarlos todos de una vez
//...
int main(){
  //...
  int diagonal[SIZE];
  //...
  for(int i = 0; i < orden; ++i){
    diagonal[i] = matriz[i][i];
    matriz[i][i] = 1;
  }
  //...
} 

Luego recuerda usar <orden> para recorrer tanto la matriz como el array ya que son las posiciones que has ocupado realmente. El resto de posiciones desde orden hasta SIZE serán basura.

Los algoritmos de ordenación más básicos son: Burbuja, Inserción y Selección. Los tres tienen un orden de eficiencia O(n²) pero son fáciles de implementar.
Si quieres algo más eficiente busca el algoritmo Quicksort o Mergesort (entre otros).

La distancia Manhattan entre dos puntos P1(x1, y1) y P2(x2, y2) se calcula como: dM = |x1 - x2| + |y1 - y2|
Por lo tanto, el tema de los puntos es "simbólico". Tienes que hacer esa operación y redondearla a 3 decimales usando:

La distancia Euclídea entre dos puntos P1 y P2 como antes se calcula como: dE(P1, P2) = SQRT((x2 - x1)² + (y2 - y1)²)
Igual que antes el tema de los puntos P1 y P2 es para que puedas plantear el ejercicio.

Ambos son ejercicios para que uses un par de funciones matemáticas: raíz cuadrada, potencia, max/min,...
Suerte.

Cuidado con esas afirmaciones... He visto matar a gente por menos

Bueno, bromas aparte. No sé si la instalación de Back Box trae por defecto el compilador de C/C++. Este es gcc: https://es.wikipedia.org/wiki/GNU_Compiler_Collection.
La verdad es que para mí no hay como programar en Linux desde la Terminal. Te bastará el propio Gedit o si quieres un editor de textos más avanzado, te recomiendo Atom (SublimeText es otra buena opción)
En caso de que no esté instalado, igual puedes instalarlo tú:
El primero es para C y el segundo para C++.

Una vez tengas escrito tu programa en un fichero de texto con extensión .c (para C) o .cpp (para C++) por ejemplo:

// Hola Mundo en C. Fichero: hola_mundo.c
#include <stdio.h>
 
int main(){
  printf("Hola Mundo!\n");
  return 0;
} 

o

// Hola Mundo en C++. Fichero: hola_mundo.cpp
#include <iostream>
using namespace std;
 
int main(){
  cout << "Hola Mundo!" << endl;
  return 0;
} 

abres una Terminal en el mismo directorio que el fichero y escribes:
o
Para compilar el programa. Se te creará un nuevo fichero con el nombre que pongas después del -o.
Y para ejecutarlos:

PD: Muchas veces, cuando se empieza con estos dos lenguajes es muy fácil mezclarlos ya que C++ acepta todo lo de C. Investiga para conocer las principales diferencias entre ambos.
Suerte.

Esto sí que promete. 
Después de darle unas cuantas vueltas creo que está cerca pero no consigo sacarlo así que dejo mi razonamiento por si alguien se anima a seguir mientras yo duermo... (Espero no soñar con esto )

La idea es tratarlo algo así como un array unidimensional, es decir, un único índice que se incrementa desde 1 hasta n siendo n el número de casillas a recorrer. Resulta que n = (N*(N-1)/2). Iremos incrementando el contador en 1 a no ser que una casilla no sea nula en cuyo caso podemos concluir que esa matriz no es triangular inferior.
Como se puede apreciar falta definir las funciones f() y g() que determinen la fila y columna del siguiente elemento en función de i.

Parece sencillo usando los operadores de división entera y módulo pero no es tan simple. Probando con matrices de orden N >= 2 (ya que de orden 1 sería triangular sin entrar por el bucle) he encontrado lo siguiente:
Y así sucesivamente. Yo creo que se ve perfectamente el patrón. El problema como ya he dicho es sacar la que sería la fórmula cerrada de f() y g().
Si alguien se quiere animar a intentar seguir o a exponer su razonamiento...