Resolución LP

#include <stdio.h>
#include <iostream>
#include <map>
#define oo 0xffff
using namespace std;

int main() {
int n, m, cases = 0, i, j, k;
char a[50], b[50];
while(scanf("%d %d", &n, &m) == 2) {
if(n == 0 && m == 0)
break;
int g[51][51], x, y;
for(i = 1; i <= n; i++) {
for(j = 1; j <= n; j++)
g[i][j] = oo;
g[i][i] = 0;
}
map<string, int> R;
map<string, int>::iterator it;
int size = 0;
while(m--) {
scanf("%s %s", a, b);
it = R.find(a);
if(it == R.end())
R[a] = ++size, x = size;
else x = it->second;
it = R.find(b);
if(it == R.end())
R[b] = ++size, y = size;
else y = it->second;
g[x][y] = g[y][x] = 1;
}
for(k = 1; k <= n; k++) {
for(i = 1; i <= n; i++) {
for(j = 1; j <= n; j++) {
if(g[i][j] > g[i][k] + g[k][j])
g[i][j] = g[i][k] + g[k][j];
}
}
}
int mx = 0;
 for(i = 1; i <= n; i++)
for(j = 1; j <= n; j++)
if(g[i][j] > mx)
mx = g[i][j];
printf("Network %d: ", ++cases);
if(mx == oo)
puts("DISCONNECTED");
else
printf("%d\n", mx);
puts("");
}
return 0;
}

c++ code:
//ak92thelooser
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <map>
using namespace std ;

map < string , int > dic ;

map < string , int > :: iterator it ;

int network [51][51] ;

int main(){
int p , r , i , j ;
string a , b ;
bool f ; int ans ,kase = 0;

while ( scanf("%d %d" ,&p , & r)){

if ( p == 0 && r == 0 )
break ;

dic.clear () ;
for ( i = 0 ; i < p ; i++)
for ( j = 0 ; j < p ; j++)
if ( i != j)
 network [i][j] = 1000;
else
network[i][j] = 0;

j=0; f = true ;

for ( i = 0 ; i < r ; i++)

{
cin >> a >> b ;
if ( !dic.count(a))
dic[a] = j++;
if (!dic.count(b))
dic[b] = j++;

network [dic[a]] [dic[b]] = network [dic[b]][dic[a]] = 1 ;

//Flyod Warshall
for ( int k = 0 ; k < p ; k++)
for ( i = 0 ; i < p ; i++)
for ( j = 0 ; j < p ; j++)
network [i][j] = min ( network [i][j] , network [i][k] + network [k]
[j]);
ans = 0 ;
for ( i = 0 ; i < p ; i++){
for ( j = 0 ; j < p ; j++)
ans = max ( ans , network[i][j]) ;

if ( ans >= 1000 )

printf("Network %d: DISCONNECTED\n",++kase );
else

printf("Network %d: %d\n",++kase , ans) ;

printf("\n");
}

return 0 ;
}
Language: C++

#include<bits/stdc++.h>
using namespace std;

using vi = vector<int>;
using ii = pair<int,int>;
using ll = long long;
using llu = unsigned long long;
const int INF = numeric_limits<int>::max() / 2;
const int MAX = 50;

map<string, int> name_index;

int get_index(string name) {

if (name_index.count(name) == 0) {
int i = name_index.size();
name_index[name] = i;
}
return name_index[name];
}

int main() {
int tc = 0;
int V, E;
int m[MAX][MAX];
while (cin >> V >> E, V) {
tc++;
name_index.clear();
fill(&m[0][0], &m[MAX][0], INF);
for (int i = 0; i < V; i++) m[i][i] = 0;
for (int i = 0; i < E; i++) {
string a, b;
cin >> a >> b;
int u = get_index(a);
int v = get_index(b);
m[u][v] = m[v][u] = 1;
}

for (int k = 0; k < V; k++)

for (int i = 0; i < V; i++)
for (int j = 0; j < V; j++) m[i][j] = min(m[i][j], m[i][k] + m[k]
[j]);

int d = 0;
for (int i = 0; i < V; i++)
for (int j = 0; j < V; j++) d = max(d, m[i][j]);
if (d == INF) {
printf("Network %d: DISCONNECTED\n\n", tc);
} else {
printf("Network %d: %d\n\n", tc, d);
}
}
}
En informática, el algoritmo de Floyd-Warshall, descrito en 1959 por Bernard Roy, es
un algoritmo de análisis sobre grafos para encontrar el camino mínimo en grafos dirigidos
ponderados. El algoritmo encuentra el camino entre todos los pares de vértices en una
única ejecución. El algoritmo de Floyd-Warshall es un ejemplo de programación dinámica.

UVa 1056 - Degrees of Separation

view source
print?
01 // UVa 1056 - Degrees of Separation
02
03 #include <iostream>
04 #include <stdio.h>
05 #include <string.h>
06 #include <map>
07 using namespace std;
08
09 int main() {
10 int t = 0;
11 int n, m;
12 while ((cin >> n >> m) && (n || m)) {
13 int nn = 0;
14 map<string, int> id;
15 int cost[51][51];
16 memset(cost, 127, sizeof(cost));
17 int oo = cost[0][0];
18 for (int j = 0; j < m; j++) {
19 string sa, sb;
20 cin >> sa >> sb;
21 if (id[sa] == 0)
22 id[sa] = ++nn;
23 if (id[sb] == 0)
24 id[sb] = ++nn;
25 cost[id[sa]][id[sb]] = 1;
26 cost[id[sb]][id[sa]] = 1;
27 }
28 int sol;
29 bool broken = false;
30 if (nn != n)
31 broken = true;
32 else {
33 for (int i = 1; i <= n; i++)
34 cost[i][i] = 0;
35 for (int k = 1; k <= n; k++)
36 for (int i = 1; i <= n; i++)
37 if (cost[i][k] != oo)
38 for (int j = 1; j <= n; j++)

39 if (cost[k][j] != oo && cost[i][j] >

cost[i][k] + cost[k][j])
cost[i][j] = cost[i][k] + cost[k]
40
[j];
41 sol = 0;
42 for (int i = 1; i <= n; i++) {
43 for (int j = i + 1; j <= n; j++)
44 if (cost[i][j] > sol)
45 sol = cost[i][j];
46 if (sol == oo) {
47 broken = true;
48 break;
49 }
50 }
51 }
52 t++;
53 if (broken)
54 printf("Network %d: DISCONNECTED\n", t);
55 else
56 printf("Network %d: %d\n", t, sol);
57 printf("\n");
58 }
59 return 0;
60 }

El link del problema es el siguiente:

1056 – Degrees of Separation
El problema es de Grafos.
Dado un grafo, nos piden revisar dos condiciones:
1.- EL grafo es desconectado
2.- Si no lo es, cual es la ruta mas larga que une a cualesquiera dos
nodos
Para la representación del grafo, es recomendable una matriz de
adyacencia, ya que el grafo es de a lo mas 50×50.
Para la manipulación de la entrada, es recomendable usar un mapa
de un String con un Entero (map<string,int>), con el
cual fácilmente a cada nombre le podemos asociar un numero.
Una vez representado el grafo en la matriz de adyacencia,
procedemos a utilizar el algoritmo de Floyd Warshall.
Este algoritmo tiene complejidad n^3, pero debido a que el grafo
es pequeño, se puede utilizar el algoritmo y obtener una respuesta
en el tiempo limite.
Una vez ejecutado el algoritmo de Floyd Warshall, procedemos a
buscar el numero mas grande de la matriz resultante.
Si el numero mas grande es igual a Infinito, tenemos que el grafo
es desconectado, si no, procedemos a imprimir el numero
obtenido.
Otro enfoque diferente, es utilizar una búsqueda por amplitud
(BFS).
Para obtener la distancia, lo que hacemos es elegir un nodo
aleatorio del grafo y ejecutamos el algoritmo.
Una vez ejecutado, nosotros conocemos la distancia de el nodo
elegido hacia todos los demás. Si alguno tiene distancia igual a
Infinito, entonces el grafo es desconectado.
Si no, procedemos a ejecutar nuevamente un BFS desde el nodo
mas lejano obtenido de la primera búsqueda en profundidad, y
sobre los resultados obtenidos, obtener la distancia mas larga.
Este problema básicamente consiste en encontrar lo que se le
conoce como diámetro de un Grafo.
Hay un teorema que menciona el hecho que se esta utilizando acá.
Si se elige un nodo aleatorio y se realiza una búsqueda en
profundidad y elegimos a su vecino mas lejano y realizamos
nuevamente una búsqueda en profundidad a partir del nodo
obtenido anteriormente, obtendremos el diámetro del Grafo.