Mensajes

Hola,
Dispongo de un modem usb para la navegación móvil desde un portátil.
Me pregunta si además de los típicos programas para controlar el downstream/upstream que llevamos gastado existe alguna manera de hacer que el tráfico sea algo más light. Es decir, reducir la cantidad de datos que bajamos desde la red para ahorrar unos MB.

Se me ha ocurrido el tema de Adblock + script block y todos estos addons que eliminan de la navegación cualquier efecto extraño etc. ¿Existe algo más?

Gracias.

Si no me equivoco necesitas usar la api WIN32

Tiene que haber algo de este estilo:

Código [Seleccionar] Expandir

RegOpenKeyEx(HKEY hKey, LPCTSTR lpszSubKey, DWORD dwReserved, REGSAM samDesired, PHKEY phkResult);

Luego puedes mirar en el msdn de microsoft.
http://msdn.microsoft.com/en-us/library/ms724256

Para el tema de los archivos, dale un ojo a esto:
http://c.conclase.net/librerias/?ansifun=fopen

Para el resto del problema, yo lo haria con expresiones regulares.

Necesitas ignorar las lineas que comienzan por // sin necesidad de cierre.
Ignorar las lineas /* hasta encontrar */.

El resto es ir leyendo linea a linea (hasta "endl", \n o como quieras ponerlo..) e ir volcando a otro archivo resultado.

Para los curiosos, os dejo la funcion de backtrack ya resuelta.

Código (cpp) [Seleccionar] Expandir


void backtrack(int nalum){
int voa = -1; /* valor optimo actual */
int *soa; /* Solucion optima actual */
int temp = 0;
soa = new int[MAX+1];
nivel = 1; /* Inicializa el nivel */
hermanos[1] = nalum; /* Ramas */

do {
generar(nalum);
if (solucion(nalum)) {
temp = beneficio(nalum);
if (temp > voa) { /* Actualizamos el valor optimo y la solucion optima */
voa = temp;
for (int i = 1; i<=nalum; i++) soa[i] = sol[i];
}
}

if (criterio(nalum)) nivel++;
else while((!masHermanos()) && (nivel > 0)) retroceso();


} while (nivel!=0);

cout<< voa << endl;
for (int i=1; i<nalum; i++)
cout << soa[i]-1 << " ";

cout << soa[nalum]-1<< endl;


delete [] soa;
}


* Generar(): Obtiene permutaciones posibles según el nº de alumnos.

Saludos y gracias por la ayuda.

Um, es más o menos lo que llevo intentando todo el tiempo, reducir el problema primero a las permutas y/o parejas para luego maximizar, pero no había pensando en un planteamiento recursivo inicial y como dices, el planteamiento iterativo es la muerte a pellizcos. Me pondré a ello, a ver si saco algo en claro.

A ver si me podéis aportar alguna idea sobre cómo afrontar esto:
Resúmen del problema...

Agrupación alumnos de dos en dos maximizando la suma de los productos del grado de amistad y la compenetración en el trabajo de alumnos que se agrupan juntos. Se dispone para ello de una matriz de amistad y otra de trabajo, donde se guardan los grados de amistad y de compenetración, que pueden no ser recíprocos, por lo que las matrices no son simétricas.

Con lo cuál tengo 2 tablas tal que así:

Amistad     Trabajo
0 5 6          0 5 3
4 0 3          3 0 2
2 1 0          1 5 0

El beneficio del que se habla se genera de la siguiente forma:

Código (cpp) [Seleccionar] Expandir

amistad[i][j]+amistad[j][i])*(trabajo[i][j]+trabajo[j][i]

Tengo que seguir obligatoriamente un esquema de backtracking iterativo ( y es lo que me está matando )...
Llevo más o menos el siguiente esqueleto:
** Intento plantearme esto como un árbol permutacional sin repetición **

Código (cpp) [Seleccionar] Expandir


do{
genera(nivel,sol);

if(solucion(sol,nalum)){
/* Sumar beneficios  y actualizar voa/soa */

}


if(criterio(nivel,sol,nalum)==true){
nivel++;
}else {
while((masHermanos(nivel,nalum)==false) && (nivel>0)) {
retroceder(nivel,sol);
nivel --;
}
}

}while(nivel!=0);


Dónde las funciones:

Genera(nivel,sol) debería generar el siguiente hermano, o el
primero, para el nivel actual.

Criterio (nivel, sol): Debería comprobar si a partir de sol[0-nivel] se puede alcanzar una solución válida. En caso de que no, podar.

MasHermanos (nivel, sol): Devuelve true si hay más hermanos del nodo actual que todavía no han sido generados.

Retrocede(nivel,sol): Retrocede la solucion y hace nivel--
--------------------------------------------------------------

Hasta ahora, todos mis intentos han acabado en un bucle infinito o bien en un falso backtrack, ya que recorría malamente.
¿Podría tratar de hacerlo aprovechando STL algorithm con la función para permutaciones?


A ver si alguien me puede echar un cable, que estoy más perdido que un ciego en el océano.

*Cualquier idea, será bien recibida *

Gracias y perdón por la biblia.

Listo, todo correcto.

Gracias por la ayuda!

Código [Seleccionar] Expandir

linux:~$ ls /etc/grub.d/
00_header        10_linux      20_memtest86+  40_custom  README
05_debian_theme  20_linux_xen  30_os-prober   41_custom


Acabo de intentarlo y queda negra la pantalla tras hacer el amago de iniciar.

Supongo que eso quiere decir que no está realmetne instalado, entonces teniendo eso en cuenta ¿cómo lo elimino del grub2? (Desde que me quitaron menu.lst no he vuelto a toquetearlo jaja)

( A lo del grub ya le doy yo respuesta )

En grub me aparece una entrada como " Versiones anteriores "

He mirado en el archivo conf del grub y hay referencias al kernel 2.6.35. No los compilé yo.